派生类继承基类赋值运算符？

Question

在我看来派生类不继承基类赋值运算符
如果派生类继承基类赋值运算符，你能解释一下下面的例子吗

在下面的代码中，我在 Derived 中重写了基类 operator=，以便 Derived 类默认赋值运算符调用重载的 operator=

#include <iostream>  
using namespace std;      
class Base  
{  
    public:  
    Base(int lx = 0):x(lx)  
    {  
    }  

    virtual Base& operator=( const Base &rhs)  
    {  
        cout << "calling Assignment operator in Base" << endl;  
        return *this;  
    }

    private:  
    int x;     
};      


class Derived : public Base  
{  
    public:  
    Derived(int lx, int ly): Base(lx),y(ly)  
    {  
    }

    Base& operator=(const Base &rhs)  
    {  
        cout << "Assignment operator in Derived"<< endl;  
        return *this;  
    }  

    private:  
    int y;    
};  



int main()  
{  
    Derived d1(10,20);  
    Derived d2(30,40);  
    d1 = d2;  
}  

它给出了输出

在 Base 中调用赋值运算符

我已经将基类 operator= 重写为派生类，所以如果派生类继承基类 operator= 那么它应该被 operator= 覆盖（我已经写在派生类中），现在派生类默认运算符= 应该调用被覆盖的版本，而不是来自基类 operator=。

Answer 1

引用标准（12.8.24）：

因为复制/移动赋值运算符是隐式声明的 如果用户未声明类，则为基类复制/移动分配 运算符总是被相应的赋值运算符隐藏 派生类 (13.5.3)。引入的使用声明（7.3.3） 来自基类的赋值运算符，其参数类型为 可能是派生类的复制/移动赋值运算符 不被视为此类运算符的显式声明，并且确实 不抑制派生类运算符的隐式声明； 由 using 声明引入的运算符被 派生类中隐式声明的运算符。

Answer 2

如果你想实现多态行为，这意味着你的基方法被覆盖，你应该这样写：

int main (){
    Derived * d1 = new Derived (10,20);  
    Derived * d2 = new Derived (30,40);
    Base * b1 = d1 ;
    Base * b2 = d2 ; 
    *b1 = *b2 ;
    *d1 = *d2 ;
} 

这将产生以下输出：

 $> Assignment operator in Derived.
 $> calling Assignment operator in Base. 

所以我在这里做的是隐式使用 c++ 动态转换。我不完全确定这是否有效，但为了说明我的观点，我认为它会很有用。当我 在取消引用 b1 和 b2 的情况下调用赋值运算符，程序首先查找在派生类上调用的函数的重写方法，如果找不到，则调用基方法类。现在，当我从 d1 调用赋值运算符时，程序将派生转换为基，并且程序无法知道 *d1 代表派生对象，因此它调用基方法。

这就是所有人。

Answer 3

除非我误解了您想要实现的目标，否则您需要一个 Derived 类的赋值运算符，即以 Derived 作为输入的运算符：

class Derived : public Base  
{  
/* ... */
public:
    Derived& operator=(const Derived &rhs)  
    {  
        cout << "Assignment operator in Derived"<< endl;  
        return *this;  
    }
};  

您的代码中发生了什么（已经在 Bo Persson 和 cmets 的回答中解释过）： 在Derived 中，您实现了一个赋值运算符，它采用Base 的实例；但是在main() 中，您分配了Derived 的实例；编译器没有看到Derived 的赋值运算符（使用Base 的运算符不计算在内），因此它生成了一个，它调用Base::operator=()，然后为Derived 的数据成员赋值。如果你定义了如上所示的赋值，它就不会发生并且你的操作符会被调用；请注意，在这种情况下，Base 和数据成员的分配不会自动发生。

---

另一种情况是，如果您真的希望分配从 Base 到 Derived，例如将其与Base 的其他派生词一起使用。那么你定义的操作符就可以工作了，但是为了将它应用到Derived的一个实例上，你需要把这个实例转换为Base：

Derived d1(10,20);  
Derived d2(30,40);  
d1 = static_cast<Base&>(d2);

不用说，您定义的运算符无法轻松访问特定于Derived 的rhs 的数据成员：例如要使用rhs.y，您需要将rhs“向上转换”为Derived：

Derived& Derived::operator=(const Base& rhs)
{
    /* ... */
    Derived* rhs_d = dynamic_cast<Derived*>(&rhs);
    if( rhs_d )
        this->y = rhs_d->y;
}

Answer 4

编译器为 Derived 生成一个默认的赋值运算符（隐藏了 Base 的运算符）。但是，默认赋值运算符会调用类成员和基类的所有赋值运算符。

Answer 5

是的，只是基类 = 运算符被派生类 = 运算符隐藏了。