C++ C+多态性+；

我正在尝试实现接下来的两个功能

Number& DoubleClass::operator+( Number& x);
Number& IntClass::operator+(Number& x);

我不知道怎么做……（他们的单向性解释如下）：

你不能

问题是

operator+

返回一个新对象，而您不能凭良心返回引用–这必然是一个悬空引用或对非托管堆内存的引用，您必须手动释放它

总之，这不能使用

操作符+

来完成，您不能

问题是

operator+

返回一个新对象，而您不能凭良心返回引用–这必然是一个悬空引用或对非托管堆内存的引用，您必须手动释放它

---

总之，这不能使用

操作符+

完成。您需要将多态性与返回的类型分开。您可以通过封装来实现这一点

例如：

class Number
{
    class NumberImpl
    {
    public:
        virtual ~NumberImpl(){}
        virtual NumberImpl* add(Number x) const = 0;
    };
    class IntClass;
    class DoubleClass;

    auto_ptr<NumberImpl> pimpl;
    Number(NumberImpl* p) : pimpl(p) {}

    //return a Number object that's the results of x+this, when x is either
    //IntClass or DoubleClass
public:
    Number operator+( const Number& x ) const { return Number(pimpl->add(x)); }
};


class Number::IntImpl : public Number::NumberImpl
{
private:
    int my_number;
public:
    //return a Number object that's the result of x+this.
    //The actual class of the returned object depends on x.
    //If x is IntImpl, then the result is new IntImpl.
    //If x is DoubleImpl, then the results is new DoubleImpl.
    virtual NumberImpl* add(Number& x) const;
};

class Number::DoubleImpl : public Number::NumberImpl
{
private:
    double my_number;
public:
    //return a new DoubleImpl object that's the result of x+this.
    //This should work if x is either IntImplor DoubleImpl
    virtual NumberImpl* add(Number& x) const;
};

类号
{
类别编号
{
公众：
虚拟~NumberImpl（）{}
虚拟数mpl*add（Number x）const=0；
};
类内类；
二等舱；
自动ptr pimpl；
数字（NumberImpl*p）：pimpl（p）{}
//返回一个数字对象，当x为
//内部类还是双重类
公众：
数字运算符+（const Number&x）const{return Number（pimpl->add（x））；}
};
类编号：：IntImpl:公共编号：：NumberImpl
{
私人：
输入我的号码；
公众：
//返回一个数字对象，它是x+这个的结果。
//返回对象的实际类取决于x。
//如果x是IntImpl，则结果是新的IntImpl。
//如果x是DoubleImpl，则结果是新的DoubleImpl。
虚拟数字mpl*添加（数字和x）常量；
};
类号：：DoubleImpl:public Number：：NumberImpl
{
私人：
把我的号码加倍；
公众：
//返回一个新的DoubleImpl对象，它是x+此操作的结果。
//如果x是intimpl或DoubleImpl，这应该可以工作
虚拟数字mpl*添加（数字和x）常量；
};

您需要将多态性与返回的类型分开。您可以通过封装来实现这一点

例如：

class Number
{
    class NumberImpl
    {
    public:
        virtual ~NumberImpl(){}
        virtual NumberImpl* add(Number x) const = 0;
    };
    class IntClass;
    class DoubleClass;

    auto_ptr<NumberImpl> pimpl;
    Number(NumberImpl* p) : pimpl(p) {}

    //return a Number object that's the results of x+this, when x is either
    //IntClass or DoubleClass
public:
    Number operator+( const Number& x ) const { return Number(pimpl->add(x)); }
};


class Number::IntImpl : public Number::NumberImpl
{
private:
    int my_number;
public:
    //return a Number object that's the result of x+this.
    //The actual class of the returned object depends on x.
    //If x is IntImpl, then the result is new IntImpl.
    //If x is DoubleImpl, then the results is new DoubleImpl.
    virtual NumberImpl* add(Number& x) const;
};

class Number::DoubleImpl : public Number::NumberImpl
{
private:
    double my_number;
public:
    //return a new DoubleImpl object that's the result of x+this.
    //This should work if x is either IntImplor DoubleImpl
    virtual NumberImpl* add(Number& x) const;
};

类号
{
类别编号
{
公众：
虚拟~NumberImpl（）{}
虚拟数mpl*add（Number x）const=0；
};
类内类；
二等舱；
自动ptr pimpl；
数字（NumberImpl*p）：pimpl（p）{}
//返回一个数字对象，当x为
//内部类还是双重类
公众：
数字运算符+（const Number&x）const{return Number（pimpl->add（x））；}
};
类编号：：IntImpl:公共编号：：NumberImpl
{
私人：
输入我的号码；
公众：
//返回一个数字对象，它是x+这个的结果。
//返回对象的实际类取决于x。
//如果x是IntImpl，则结果是新的IntImpl。
//如果x是DoubleImpl，则结果是新的DoubleImpl。
虚拟数字mpl*添加（数字和x）常量；
};
类号：：DoubleImpl:public Number：：NumberImpl
{
私人：
把我的号码加倍；
公众：
//返回一个新的DoubleImpl对象，它是x+此操作的结果。
//如果x是intimpl或DoubleImpl，这应该可以工作
虚拟数字mpl*添加（数字和x）常量；
};

我想

IntClass:：operator+（）

应该是

公共的

，对吧？你的解释有什么问题吗？我想

IntClass:：operator+（）

应该是

公共的

，对吧？你的解释有什么问题吗？“做不到”--他们在争吵。它需要重新设计，但肯定是可能的。“本：……不能使用该接口，而不打破使用API地狱的C++的基本假设。@本：Scott Meyers，有效C++，项目21（第三ED）/ 23（第二版）：“当你必须返回一个对象时，不要试图返回引用”。超过4页，有一个优秀的分析，为什么

operator+

必须返回一个对象（而不是引用）。@sbi:所以返回一个对象。按价值计算。多态性要求周围有一个指针或引用，而不是返回值是指针或引用。看看我的答案。@Ben-你不能。你会返回什么？如果你能把数的任何一个导数直接转换成一个数值，那么这些导数什么也不做。如果他们正在做一些事情，那么将它们中的任何一个转换成一个数值将会丢失任何使它们成为导数的有趣数据。“不可能”——他们的格言。它需要重新设计，但肯定是可能的。“本：……不能使用该接口，而不打破使用API地狱的C++的基本假设。@本：Scott Meyers，有效C++，项目21（第三ED）/ 23（第二版）：“当你必须返回一个对象时，不要试图返回引用”。超过4页，有一个优秀的分析，为什么

operator+

必须返回一个对象（而不是引用）。@sbi:所以返回一个对象。按价值计算。多态性要求周围有一个指针或引用，而不是返回值是指针或引用。看看我的答案。@Ben-你不能。你会返回什么？如果你能把数的任何一个导数直接转换成一个数值，那么这些导数什么也不做。如果他们正在做一些事情，那么将它们中的任何一个转换成一个数值将会丢失任何使它们成为导数的有趣数据。