C++ lier des membres de classes de base à des membres de classe dérivés

Question

class B_mem { 
    public: 
    int b_var; 
}; 
class D_mem : public B_mem { 
    public: 
    int d_var; 
}; 

class B { 
    public: 
    B_mem b_member; 
}; 

class D : public B { 
    public: 
    D_mem d_member; 
}; 


int main() { 
    D derived; 
    D_mem dmem; 
    dmem.b_var = 2; 
    dmem.d_var = 3; 
    B* b_ptr = &derived; 
    std::cout << b_ptr->b_member.b_var; // Doesn't print 2 
} 

Comment puis-je structurer les classes de sorte que lorsque je mets/mette à jour D_mem, il mette/met à jour automatiquement B_mem (le cas échéant)? Dans l'exemple ci-dessus, je crée D et remplis D_mem mais j'accède à D avec un pointeur de type B. Je veux pouvoir accéder aux membres de classe de base de D_mem dans D à B_mem. Je me demande s'il y a quelque chose avec le polymorphisme, les constructeurs de copie, ou les fonctions d'ensemble qui me permettront de faire ceci sans devoir garder manuellement D_mem et B_mem en accord.

Answer 1

std::cout << b_ptr->b_member.b_var; // Doesn't print 2

Bien sûr, il ne fonctionne pas.

Les lignes

D_mem dmem; 
dmem.b_var = 2; 
dmem.d_var = 3; 

n'a rien fait pour changer la variable membre de derived. Ils sont toujours dans un état non initialisé.

Vous pouvez utiliser:

int main() { 
    D derived; 

    D_mem& dmem = derived.d_member; // Get a reference to an existing object 
    dmem.b_var = 2;     // Modify the referenced object 
    dmem.d_var = 3; 

    // That still doesn't change b_member. 
    // Need to update it too. 
    derived.b_member.b_var = 2; 

    B* b_ptr = &derived; 
    std::cout << b_ptr->b_member.b_var; // Doesn't print 2 
} 

ou

int main() { 
    D derived; 
    D_mem dmem; 
    dmem.b_var = 2; 
    dmem.d_var = 3; 

    derived.d_member = dmem; // Set the value of derived. 
    derived.b_member = dmem; 

    B* b_ptr = &derived; 
    std::cout << b_ptr->b_member.b_var; // Doesn't print 2 
} 

Re:

Je me demande s'il y a quelque chose avec le polymorphisme, copier les constructeurs, ou des fonctions définies qui permettront moi de le faire sans avoir à garder manuellement D_mem et B_mem en accord.

Vous pouvez le faire si vous fournissez les fonctions membres qui prennent soin de ces détails et de faire les variables membres privées, mais il devient malpropre puisque vous avez essentiellement deux instances de B_mem dans D.

Le code devient plus simple et plus facile à maintenir si vous utilisez un pointeur au lieu d'objets.

Voici un exemple d'implémentation:

#include <iostream> 
#include <memory> 

class B_mem { 
    public: 
     int b_var; 
     virtual ~B_mem() {} 
}; 

class D_mem : public B_mem { 
    public: 
     int d_var; 
}; 

class B { 
    protected: 
     std::shared_ptr<B_mem> b_member; 

    public: 

     B(std::shared_ptr<B_mem> member) : b_member(member){} 
     virtual ~B() {} 

     virtual B_mem& getMember() = 0; 

     virtual B_mem const& getMember() const = 0; 
}; 

class D : public B { 

    public: 

     D() : B(std::shared_ptr<B_mem>(new D_mem)){} 

     D_mem& getMember() 
     { 
     return *(std::dynamic_pointer_cast<D_mem>(b_member)); 
     } 

     D_mem const& getMember() const 
     { 
     return *(std::dynamic_pointer_cast<D_mem>(b_member)); 
     } 
}; 


int main() { 
    D derived; 

    derived.getMember().b_var = 2; 
    derived.getMember().d_var = 3; 

    B* b_ptr = &derived; 
    std::cout << b_ptr->getMember().b_var << std::endl; 
} 

sortie:

2