基类中的运算符 + 重载并在派生类中使用它

Question

我有 2 个类，基类（带有复制构造函数）和派生类，在基类中我重载了 operator+：

class Base {

  public:

     Base(const Base& x) {
         // some code for copying
     }

     Base operator+(const Base &bignum) const {
         Base x;
         /* ... */
         return x;
     }
};

class Derived : public Base {
};

当我尝试做类似的事情时

Derived x;
Derived y;
Derived c=x+y;

我收到错误：conversion from "Base" to non-scalar type "Derived" derived 问题可能出在那个运算符 + 返回Base 类型的对象，我想将它分配给Derived 类型的对象？

Answer 1

事实上，您不需要重新定义 operator+（除非您的设计需要它，正如 Ajay 的示例所指出的那样）。

效果比你想象的要好

举个简单的例子：

struct Base {
    Base operator+ (Base a) const
        { cout <<"Base+Base\n"; }
    Base& operator= (Base a)  
        { cout<<"Base=Base\n"; }
};
struct Derived : public Base { };

int main() {
    Base a,b,c;  
    c=a+b;     // prints out "Base+Base" and "Base=Base"
    Derived e,f,g; 
    e+f;       // prints out "Base+Base" (implicit conversion); 
}  

这很有效，因为当遇到e+f 时，编译器会找到基类的operator+，然后他隐式地将Derived 转换为Base，并计算出Base 类型的结果。你可以很容易地写c=e+f。

缺少什么？

问题仅始于派生分配。只要你尝试g=e+f;，你就会得到一个错误。编译器不确定如何将 A 放入 B。这种谨慎是由常识证明的：所有的猿都是动物，但所有的动物都不一定是猿。

如果Derived 的字段比Base 多，这一点就更加明显：编译器应该如何初始化它们？基本上，如何告诉编译器他应该如何用其他东西制作Derived？使用构造函数！

struct Derived : public Base {
    Derived()=default; 
    Derived(const Base& a) : Base(a) { cout<<"construct B from A\n"; }
};

一旦你定义了这个，一切都会如你所愿：

 g=e+f;   // will automatically construct a Derived from the result
          // and then execute `Derived`'s default `operator=` which 
          // will call `Base`'s `operator=`  

这里是live demo。

Answer 2

这不是一个正确的设计。考虑具有x 和y 的类Point2D，以及继承自Point2D 的具有附加成员z 的Point3D 类。你的事情会有所帮助吗？

Point2D operator+(const Point2D &pt) const;

调用时：

Point3D a, b;
Point3D c = a+b;

?

Answer 3

是的，这正是问题所在。加号运算符只保证返回一个 Base 对象，因此您可以将其分配给 Base 对象。所有 Derived 对象都可以替换为 Bases，但不能以其他方式替换。