C++ Utilisation de deux variables de même nom dans les classes dérivées et de base

Question

J'ai déjà posté sur ce problème avant (Here), il s'agit d'une approche différente d'une solution. Cette solution semble mieux encapsuler le comportement de ceux qui implémentent la classe, puisqu'elle les empêche d'avoir explicitement besoin de lancer.

Voici le problème:

J'ai un projet dans lequel je veux isoler le comportement de base dans la plupart des objets, tout en fournissant un comportement supplémentaire à travers des objets dérivés. Assez simple:

class BaseA 
{ 
    virtual void something() {} 
} 


class DerivedA : public BaseA 
{ 
    void something() {} 
    void somethingElse() {} 
} 

Maintenant, nous allons dire que j'ai aussi un deuxième ensemble de classes, même schéma d'héritage, sauf qu'ils agrègent les classes ci-dessus. Cependant, j'aimerais que la version de base utilise la classe de base et la version dérivée dans la classe dérivée. Ma solution je pensais à «cacher» la variable de classe de base en utilisant le même nom;

class BaseB 
{ 
    BaseA *var; 

    BaseB() 
    { 
     var = new BaseA(); 
    } 

    virtual void anotherThing1(); 
    virtual void anotherThing2(); 
    virtual void anotherThing3(); 
} 

class DerivedB : public BaseB 
{ 
    DerivedA *var; 

    DerivedB() 
    { 
     var = new DerivedA(); 
    } 

    void anotherThing1(); 
    void anotherThing2(); 
    void anotherThing3(); 
    void andAnother1(); 
    void andAnother2(); 
} 

L'objectif de cette approche est de sorte que les fonctions qui dépendent de la classe ne agrégée dérivée plus besoin de jeter explicitement pour obtenir la fonctionnalité acquise.

void func1(BaseB &b) 
{ 
    b.anotherThing1(); 
    b.var->something(); 
} 

void func2(DerivedB &b) 
{ 
    b.anotherThing1(); 
    b.andAnother1(); 
    b.var->something(); 
    b.var->somethingElse(); 
} 

void main(int argc, char **argv) 
{ 
    BaseB baseB; 
    DerivedB derivedB; 

    func1(baseB); 
    func1(derivedB); 
    func2(derivedB); 
} 

Cela serait-il considéré comme une mauvaise pratique?

Answer 1

Cela serait-il considéré comme une mauvaise pratique?

Oui, ce serait une mauvaise pratique, car le var dans le Base serait utilisé. Il ne ressemble pas à DerivedB devrait être dérivez de BaseB: au contraire, ils doivent provenir de la même classe de base abstraite, comme ceci:

class AbstractB { 
public: 
    virtual void anotherThing1() = 0; 
    virtual void anotherThing2() = 0; 
    virtual void anotherThing3() = 0; 
}; 
class DerivedB1 : public AbstractB { // Former BaseB 
    BaseA *var; 

public: 
    DerivedB1() { 
     var = new BaseA(); 
    } 
    virtual void anotherThing1(); 
    virtual void anotherThing2(); 
    virtual void anotherThing3(); 
}; 
class DerivedB2 : public AbstractB { // Former DerivedB 
    DerivedA *var; 
public: 
    DerivedB2() { 
     var = new DerivedA(); 
    } 
    void anotherThing1(); 
    void anotherThing2(); 
    void anotherThing3(); 
    void andAnother1(); 
    void andAnother2(); 
}; 

Principe général utilisé ici est que vous devriez essayer de faire tout votre non classes de feuille dans votre résumé de hiérarchie d'héritage.