C ++中的运算符重载和多态

Question

I'm writing a simple wrapper to basic numeric types in C++.

I want to have an abstract base class Number and a few derived classes like Short, Integer, Long and Double.

For the Number class to be abstract I need to declare some pure virtual methods that are common for all numeric types, for example basic operators (+, -, *, /):

class Number {
    public:
    [...]
        virtual Number operator+(Number) = 0;
        virtual Number operator-(Number) = 0;
        virtual Number operator*(Number) = 0;
        virtual Number operator/(Number) = 0;
    [...]
}

but I'm afraid this will not work when I will try to implement that operators in derived classes but with the concret types like:

class Integer : public Number {
    public:
    [...]
        Integer operator+(Integer);
        Integer operator-(Integer);
        Integer operator*(Integer);
        Integer operator/(Integer);
    [...]
}

when I try to compile this code I get this kind of messages:

Number.hpp error: cannot declare parameter 'anonymous' to be of abstract type 'Number' note: because the following virtual functions are pure within 'Number': note: virtual Number Number::operator+(Number)

I'm sure I can do this, but so far I have no idea how. Could you please help me a little? ;)

Answer 1

1) You must return a reference (or pointer), since Number is abstract
2) The parameter must also be a reference (same reason)
3) the parameter to the derived class must be the same
4) you are missing 'virtual' on the overrides

Here's a hack that kinda works:

class Number {
    public:
        virtual Number& operator+(const Number&) = 0;
};

class Integer : public Number {
    public:
        virtual Integer& operator+(const Number&) override;
    private:
        int i;
};

Integer& Integer::operator+(const Number& n)
{
    static Integer i;
    const Integer* param = dynamic_cast<const Integer*>(&n);
    assert(param);
    i.i = this->i + param->i;
    return i;
}

Note, returning a reference to a static can surprise you in some cases, see comments.
Also, polymorphism might not be the best fit for what you are trying to do, for example,
do you really need to keep track of numbers, that you don't know what type they are?

If you really want polymorphism here, smartpointers should probably accompany the solution