Comment remplacer facilement une classe de base

Question

je la hiérarchie suivante des classes

class classOne 
{ 
    virtual void abstractMethod() = 0; 
}; 

class classTwo : public classOne 
{ 
}; 

class classThree : public classTwo 
{ 
}; 

Tous classOne, classTwo et classThree sont des classes abstraites, et j'ai une autre classe qui définit les méthodes virtuelles pures

class classNonAbstract : public classThree 
{ 
    void abstractMethod(); 

    // Couple of new methods 
    void doIt(); 
    void doItToo(); 
}; 

et maintenant je dois différemment ... J'ai besoin comme

class classNonAbstractOne : public classOne 
{ 
    void abstractMethod(); 

    // Couple of new methods 
    void doIt(); 
    void doItToo(); 
}; 

class classNonAbstractTwo : public classTwo 
{ 
    void abstractMethod(); 

    // Couple of new methods 
    void doIt(); 
    void doItToo(); 
}; 

et

class classNonAbstractThree : public classThree 
{ 
    void abstractMethod(); 

    // Couple of new methods 
    void doIt(); 
    void doItToo(); 
}; 

Mais toutes les classes nonAbstract ont les mêmes nouvelles méthodes, avec le même code ... et je voudrais éviter de copier toutes les méthodes et son code à chaque classe nonAbstract. Comment pourrais-je accomplir cela?

Espérons qu'il est compréhensible ...

Answer 1

template<class Base> 
struct Concrete : Base { 
    void abstractMethod(); 

    void doIt() { 
    // example of accessing inherited members: 
    int n = Base::data_member; // or this->data_member 
    n = Base::method(); // non-virtual dispatch 
    n = this->method(); // virtual dispatch 

    // since Base is a template parameter, 'data_member' and 'method' are 
    // dependent names and using them unqualified will not properly find 
    // them 
    } 
    void doItToo(); 
}; 

typedef Concrete<classOne> classNonAbstractOne; // if desired, for convenience 

Assurez-vous de donner à vos classes de base abstraites soit un destructor public virtuel ou faire le destructor protégé (il ne doit pas être virtuel, mais peut encore être).

Parce que le modèle doit être analysé avec des noms regardé sans savoir encore exactement ce que base sera, vous devez utiliser soit Base::member ou this->member d'accès membres hérités.

Answer 2

J'essaye généralement d'éviter l'héritage si possible (sauf pour les classes abstraites pures qui définissent des interfaces pures) parce qu'il crée un couplage étroit. Dans de nombreux cas, la composition est la meilleure alternative.

De plus, les choses ont tendance à être salissantes avec les structures d'héritage complexes. Ce n'est pas facile de dire à partir de votre description ce qui est le meilleur dans ce cas particulier. Juste en faisant remarquer cela comme une règle générale.