Inheriting operator +()

How to inherit overloaded operator +()?

For example, I have two classes:

class Bin : public Number<2, 256>
{
public:
    Bin(const char* number = NULL) :
        Number(number)
    {}
};

and

template <unsigned int BASE, unsigned int ORDER>
class Number
{
private:
    ...

public:
    Number(const char开发者_如何转开发* number = NULL) {
        ...
    }

    const Number& operator +=(const Number& number) {
        ...
    }

    Number operator +(const Number& number) const {
        Number result = *this;
        return result += number;
    }
};

operator +() returns Number. But I want to do:

Bin firstNum("101010111010");
Bin secondNum("1101011101");
Bin result = firstNum + secondNum;

Type of (firstNum + secondNum) - Number<2, 256> not Bin. Must I overload +() in every inheritor?

---

Consider what would need to happen in a slightly more complicated example than yours, where the derived class Bin has its own member variables. How could the base-class function possibly know what to do in order to create the return value? And what would it do in "mixed-mode" additions? (e.g. if one argument was a Bin, and the other was a Blah).

So yes, you will need to define specific operators everywhere that you want specific behaviour. Note that this is true not just of overloaded operators, but member functions in general.

---

It would probably be easier to just duplicate the implementation for operator+ in all derived classes. However, if you're feeling adventurous you could use the curiously recurring template pattern to enforce type consistency in your Number template class.

---

Can't be done, operators can't be made to be virtual(i.e. inherited). NOT directly at least.

You can do this:

class Base {
public:
   Base operator+(const Base& addend) { return addOp(addend) ; }
private:
   virtual Base addOp(const Base& addend) ;
} ;

and then override addOp to your heart's content. However you NEED to make sure that anything that inherits can return a 'Base' that will work with anything else. This gets to be pretty complicated pretty fast.