Question

我正在寻找以下“问题”的优雅解决方案：

考虑类Base和Child，以及operator +在这里工作的方式：

class Base
{
public:
    Base(int a=0) : mValue(a) {};
    Base(const Base& rhs) : mValue(rhs.mValue) {};
    Base& operator=(const Base& rhs) {
        if (this==&rhs) return *this;
        mValue=rhs.mValue;
    }


    friend const Base operator+(Base &lhs, Base &rhs);

private:
    int mValue;
};

const Base operator+(Base &lhs, Base &rhs)
{
    Base result(lhs.mValue+rhs.mValue);
    return result;
}

class Child : public Base
{
public:
    Child(int a=0) : Base(a) {};
};

int main()
{
    Child a(2);
    Child b(5);
    Child c(a+b);  // **** This line ****
            Child d;
            d=(a+b); // **** or this other one ****

}

main 中标记的行给出错误： 无法从'const Base'转换为'Child'

我完全理解运算符已在 Base 类中定义，并返回 Base 类型的对象，该对象无法转换为 Child 。一个解决方案是为 Child 类重载 operator + ，但我想知道是否有更好，成本更低的方法。我的印象是我忘记了一个更容易的选择。谢谢！

Answer 1

您可以定义构造函数Child(Base& obj)然后Child c=(a+b);语句就可以了，然后您可以根据需要使用基础对象。

Answer 2

没有更简单的选择。

运营商重载和类层次结构并不是很想混合。当一个应该是值类型的类型（或者你为什么要重载运算符？）是层次结构的一部分时，我个人非常怀疑。你能描述一下你的实际架构吗？在那里重载运算符真的有意义吗？

Answer 3

如果您想在不添加适当构造函数的情况下从基础构建子项，则还有另一种选择。您可以在基类中声明强制转换运算符，并返回mValue：

operator int() const;

这样，编译器就会隐式地完成工作。

PS ：确保添加剂操作符的正确性：

friend Base operator+(const Base &lhs, const Base &rhs);

重载运算符+

3 个答案: