如何使这个运算符=过载工作

Question

我正在尝试使operator=成为虚拟的，就像这样：

#include <iostream>
#include <string>
class Base {
public:
std::string field1;
Base(std::string str) : field1(str) {}
virtual Base& operator=(const Base& other)
{
field1 = other.field1;
return *this;
}
};
class Derived : public Base {
public:
std::string field2;
Derived(std::string str1, std::string str2) : Base(str1), field2(str2) {}
virtual Derived& operator=(const Derived& other) override
{
Base::operator=(other);
field2 = other.field2;
return *this;
}
};

然而，这会导致编译器错误，因为Derived函数实际上并没有重载任何内容，所以签名是不同的。

是否可以覆盖operator=来编写这样的代码？

Base* ptr = new Derived("old 1", "old 2");
Derived derived("new 1", "new 2");
*ptr = derived; // <- use the derived class operator= to assign both field1 and field2

Answer 1

此操作员

virtual Derived& operator=(const Derived& other);

不重写基类中声明的复制赋值运算符。

你必须写

Derived& operator=(const Base& other) override;

即参数的类型应为const Base &。

这是一个示范节目。

#include <iostream>
struct A
{
virtual A & operator =( const A & )
{
std::cout << "A::operator =n";
return *this;
}
};
struct B : A
{
virtual B & operator =( const A &a ) override
{
A::operator =( a );
std::cout << "B::operator =n";
return *this;
}
};

int main() 
{
B b1;

A &rb1 = b1;

B b2;
b2 = rb1;

return 0;
}

其输出为

A::operator =
B::operator =