Question

为了简化我的疑问，我写了一些虚拟代码，突出了同样的问题。

所以，我有一个名为Box的类，它有一个+运算符的重载。接下来，声明一个名为Cube的类，它继承自Box类。我希望能够使用Box类中定义的+重载。这对我来说似乎是合理的，因为任何Cube对象也是Box对象，并且继承的变量应该可以从继承的函数进行配置。当前的问题在于+运算符返回一个Box对象，该对象无法转换为Cube对象。但我无法使用*这是一个Cube对象的信息。

示例代码：

#include <iostream>
using namespace std;

class Box {
   double length, breadth, height;

public:
   Box();
   Box(double l, double b, double h){
      length=l;breadth=b;height=h;
   }
   double getVolume() {
      return length * breadth * height;
   }
   // Overload + operator to add two Box objects.
   Box operator+(const Box& b) {
      Box box;
      box.length = this->length + b.length;
      box.breadth = this->breadth + b.breadth;
      box.height = this->height + b.height;
      return box;
   }
};

class Cube: public Box {
public:
   Cube();
   Cube(double size):Box(size,size,size){}
   Cube operator+(const Cube& b) {
        return (Box(*this)+b);   // this is wrong
   }
};

// Main function for the program
int main( ) {
   Cube C1(5),C2(10),C3; 
   C3=C1+C2;
   cout << "Volume of C3 : " << C3.getVolume() <<endl;
   return 0;
}

我已经阅读了很多关于这个主题的答案。 This可能是最接近这个问题的。但是接受的答案会将Cube对象转换为Box对象，这在以后的部分中是不受欢迎的。

编辑：社区的许多人都不清楚这个问题。（对不起。但这是我在堆栈上的第一个问题）。请不要过度重载函数中发生的事情。我的想法是，我不想将Box类中+运算符的内容复制到Cube类的+运算符。我需要Box类的+运算符返回一个Box对象，并在Cube类上运行+运算符，除其他外，对继承的变量执行Box +操作，并返回一个Cube类对象。

Answer 1

如果你添加一个带有Box的Cube构造函数，那么代码将起作用：

Cube(Box const &);

从现在开始，编译器可以隐式地从Box转换为Cube。

直播：https://godbolt.org/g/JMAuz2

当然，你需要在新的构造函数中加入一些逻辑，以确保该框实际上是一个多维数据集 - 如果不是则可能抛出异常。

Answer 2

我不是你面临的问题，因为你的问题很不清楚。但是，我认为这就是你想要的。希望这有帮助

#include <iostream>
using namespace std;

class Box {
public:
double length, breadth, height;
Box(){}
Box(double l, double b, double h) {
    length = l; breadth = b; height = h;
}
double getVolume() {
    return length * breadth * height;
}
// Overload + operator to add two Box objects.
Box operator+(const Box& b) {
    Box box;
    box.length = this->length + b.length;
    box.breadth = this->breadth + b.breadth;
    box.height = this->height + b.height;
    return box;
}
};

class Cube : public Box {
public:
Cube(){}
Cube(double size) :Box(size, size, size) {}
Cube operator+(const Cube& b) {
    Box b1(this->length, this->breadth,this>height),b2(b.length,b.breadth,b.height),b3;
    Cube t(this->breadth);
    b3 = b1 + b2;
    t.length = b3.length;
    t.breadth = b3.breadth;
    t.height = b3.height;
    return (t);  
}
};

// Main function for the program
int main() {
  Cube C1(5), C2(10), C3;
  C3 = C1 + C2;
  cout << "Volume of C3 : " << C3.getVolume() << endl;
  return 0;
 }

Answer 3

Cube从Box继承operator +。您不需要在Cube中再次实现它。但是当删除Cube运算符+时，您会注意到C3 = C1 + C2;给出错误。 C1 + C2导致Box类型，并且您希望将其分配给多维数据集类型。她应该问自己一个问题：C3应该是Cube类型吗？如果你添加两个立方体，你会得到另一个立方体吗？我不这么认为。所以C3应该是Box型。然后代码适合我。

。你也不需要这个 - ＆gt; [成员变量]。您已经可以访问私有成员变量，因为您将operator +定义为成员函数。

编辑：只是为了添加工作代码

#include <iostream>

class Box
{
private:
    double length;
    double breadth; // ?? do you mean "width"?
    double height;

public:
    Box() {}
    Box(const double l, const double b, const double h)
        : length(l)
        , breadth(b)
        , height(h)
    {}

    // I don't know why the members are private? But you need access to check for a cube.
    double getLength() const { return length; }
    double getBreadth() const { return breadth; }
    double getHeight() const { return height; }

    double getVolume() const
    {
        return length * breadth * height;
    }

    // Overload + operator to add two Box objects.
    Box operator+(const Box& b)
    {
        return Box (
            length + b.length,
            breadth + b.breadth,
            height + b.height);
    }
};

class Cube : public Box
{
public:
    Cube(const double size = 0)
        :Box(size, size, size)
    {}

    Cube(const Box& b)
        : Cube(b.getLength())
    {
        if ((b.getLength() != b.getBreadth()) || (b.getLength() != b.getHeight()))
            throw std::invalid_argument("Box is not a Cube!");
    }
};

// Main function for the program
int main() {
    Cube C1(5), C2(10), C3;
    C3 = (C1 + C2);
    std::cout << "Volume of C3 : " << C3.getVolume() << std::endl;
    int temp;
    std::cin >> temp;
    return 0;
}

C ++：使用父类操作符函数更新子类对象

3 个答案: