Polymorphismus in C++

Question

Ich versuche, die nächsten 2 Funktionen

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

Ich bin nicht sicher zu implementieren, wie es geht .. (ihre Innigkeit erklärt weiter unten):

class IntClass; 
    class DoubleClass; 

class Number { 
     //return a Number object that's the results of x+this, when x is either 
     //IntClass or DoubleClass 
     virtual Number& operator+(Number& x) = 0; 
}; 


class IntClass : public Number { 
    private: 
     int my_number; 
     //return a Number object that's the result of x+this. 
     //The actual class of the returned object depends on x. 
     //If x is IntClass, then the result if IntClass. 
     //If x is DoubleClass, then the results is DoubleClass. 
    public: 
     Number& operator+(Number& x); 
}; 


class DoubleClass : public Number { 
    private: 
     double my_number; 
    public: 

     //return a DoubleClass object that's the result of x+this. 
     //This should work if x is either IntClass or DoubleClass 
     Number& operator+(Number& x); 
}; 

Answer 1

Sie müssen den Polymorphismus vom zurückgegebenen Typ trennen. Sie können das mit Kapselung machen.

Zum Beispiel:

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; 
}; 

Answer 2

Sie können‘ t.

Das Problem ist, dass operator + gibt ein neues Objekt und Sie können einen Verweis nicht mit gutem Gewissen zurückgeben - dies würde entweder unbedingt ein baumelnden Verweis oder ein Verweis auf nicht verwalteten Heap-Speicher, die Sie würde manuell befreien muß.

Zusammenfassend kann dies nicht mit der operator + durchgeführt werden.