Наследование оператора + ()

Question

Как наследовать перегруженный оператор + ()?

Например, у меня есть два класса:

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

и

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

Оператор + () возвращаетЧисло.Но я хочу сделать:

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

Тип (firstNum + secondNum) - Number <2, 256>, а не Bin.Должен ли я перегружать + () в каждом наследнике?

Answer 1

Рассмотрим, что должно произойти в несколько более сложном примере, чем ваш, где у производного класса Bin есть свои собственные переменные-члены.Как функция базового класса могла знать, что делать, чтобы создать возвращаемое значение?И что это будет делать в дополнениях "смешанного режима"?(например, если один аргумент был Bin, а другой - Blah).

Так что да, вам нужно будет определять конкретные операторы везде, где вам нужно конкретное поведение.Обратите внимание, что это верно не только для перегруженных операторов, но и для функций-членов в целом.

Answer 2

Вероятно, было бы проще просто продублировать реализацию для operator+ во всех производных классах. Однако, если вы испытываете приключения, вы можете использовать любопытно повторяющийся шаблонный шаблон для обеспечения согласованности типов в вашем шаблонном классе Number.

Answer 3

Не может быть сделано, операторы не могут быть виртуальными (то есть наследуемыми).По крайней мере, НЕ напрямую.

Вы можете сделать это:

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

и затем переопределить addOp для вашего сердца.Однако вы ДОЛЖНЫ убедиться, что все, что унаследовано, может вернуть 'Base', которая будет работать с чем-либо еще.Это будет довольно сложно довольно быстро.