opérateur Héritant +()

Question

Comment hériteront opérateur surchargée +()?

Par exemple, j'ai deux classes:

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

et

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

opérateur +() retourne le nombre. Mais je veux faire:

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

Type de (firstNum + secondNum) - Nombre < 2, 256> non Bin. Dois-je surcharger +() dans chaque héritier?

Answer 1

ne peut se faire, les opérateurs ne peuvent pas être rendus virtuels (i.e.. Héritées du passé). PAS directement au moins.

Vous pouvez le faire:

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

puis passer outre ADDOP au contenu de votre cœur. Cependant, vous devez vous assurer que tout ce qui hérite peut renvoyer une 'base' qui fonctionnera avec n'importe quoi d'autre. Cela devient assez compliqué assez rapidement.

Answer 2

Tenir compte ce qui devrait se produire dans un exemple un peu plus compliqué que le vôtre, où la classe dérivée Bin a ses propres variables membres. Comment la fonction de classe de base pourrait-elle savoir quoi faire pour créer la valeur de retour? Et que ferait-il dans les ajouts "mixtes"? (par exemple si un argument était un Bin, et l'autre était un Blah).

Alors oui, vous aurez besoin de définir des opérateurs spécifiques partout que vous voulez un comportement spécifique. Notez que ceci est vrai non seulement des opérateurs surchargés, mais des fonctions membres en général.

Answer 3

Il serait probablement plus facile de reproduire simplement la mise en œuvre de operator+ dans toutes les classes dérivées. Cependant, si vous vous sentez aventureux, vous pouvez utiliser le curiously recurring template pattern pour appliquer la cohérence de type dans votre classe de modèle Number.