不自动继承的函数 在C++中，我在布鲁斯Ekell中读取不自动继承的函数是： #include<iostream> using namespace std;` class A { public: A & operator= (A &a) { cout<<" base class assignment operator called "; return *this; } }; class B: public A { }; int main() { B a, b; a.A::operator=(b); //calling base class assignment operator function // using derived class a = b; // this also works //getchar(); return 0; } 建设者 析构函数 运算符=（因为它执行类似构造函数的操作）

但这段代码说明了另外一件事

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

#包括
使用命名空间std；`
甲级{
公众：
A&A运算符=（A&A）{
cout事实上，说
运算符=
不是继承的是不正确的。问题是它被派生类隐式生成的
运算符=
隐藏，因此（例如），下面代码中的赋值是非法的：

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

A a;
B b;
b = a;

因为类
B
没有任何
运算符=
接受
A
，而只有隐式生成的具有以下签名的复制赋值运算符：

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

B& operator = (B const&)

这种情况与派生类中的常规成员函数在基类中隐藏同名成员函数的情况没有什么不同

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

对于常规成员函数，您可以在类中使用
声明，使基类的
运算符=
可用：

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

class B: public A
{
public:
    using A::operator =;
//  ^^^^^^^^^^^^^^^^^^^^
};

这将使上一个示例中的赋值得以编译。
根据，当您没有为类定义构造函数、析构函数或
=
运算符时，它会自动创建这三个运算符的简单版本

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

代替继承，如果您不自己创建这些函数，这些函数将由编译器合成。（对于构造函数，您不能创建任何构造函数，以便编译器合成默认构造函数和复制构造函数。）合成构造函数使用memberwise初始化，合成运算符=使用memberwise赋值。“

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

因此，B有一个由编译器自动生成的合成
=
运算符。
没有继承
a
的运算符=（）。相反，基赋值运算符是从派生类赋值运算符调用的，因为隐式赋值运算符“简单”赋值所有成员和基类

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

（有关默认复制或移动分配何时隐式生成以及以何种形式生成的信息，请参见标准[草案N3242]§12.8。）

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

标准（草案N3242）规定：

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

§12.8 / 29
非联合类X的隐式定义的复制/移动赋值运算符对其子对象执行成员式复制/移动赋值。首先按照其在基说明符列表中的声明顺序分配X的直接基类，然后按照i的顺序分配X的直接非静态数据成员在类定义中声明的

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

在这里，我们将赋值运算符设置到位

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

X
是
B
而
直接基类是
A
。因此在
B
的隐式赋值操作符中，它的
A
类型的子对象将使用
A:：operator=（…）
进行赋值

#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}   

注意：通过常量引用（或使用复制和交换时通过值）提供赋值运算符参数是有利的.
但是如果我不使用它，那么只写a=b？如何调用基类版本？请参阅/p@akash：
a
和
b
是
b
类型的对象。正如我在回答中所解释的，
b
有一个隐式生成的
操作符=
，因此表达式
a=b
是有效的。但这意味着citly生成的运算符对基类隐藏了该运算符，因此，如果您希望通过依赖该赋值运算符将
A
类型的对象分配给
B
类型的对象，您将遇到麻烦。我想我的答案解释了这一点that@AndyProwl我认为op只是没有意识到这样一个事实，即
B
将为其类型为
A
的子对象调用
A
的赋值运算符。您正在显式调用该函数。为什么会感到惊讶？他对两个赋值都调用A:：operator=（）我猜。但是由于A是每个B的一部分，B的隐式赋值将调用子对象A.AkASH的赋值。程序应该输出<代码>基类赋值操作符，称为基类赋值操作符，称为。@ AKASH，如果您的问题已被回答，请考虑标记正确的答案。
#include<iostream>             
using namespace std;`                   

class A {
 public:
   A & operator= (A &a) {
    cout<<" base class assignment operator called ";
    return *this;
   }
};

class B: public A { };

int main()
{
  B a, b;
  a.A::operator=(b); //calling base class assignment operator function
                // using derived class
  a = b; // this also works
  //getchar();
  return 0;

}