Objets partagés C++

Question

J'ai quatre classes A, B, C et D.

• classe A a un membre de la classe b B.
• La classe B a un membre c de la classe C.

A comporte un élément D* dpointer;

Cette hiérarchie doit être préservée (en fait, ceci est une interface graphique avec l'application, la fenêtre, le panneau comme A, B et C). Maintenant, B et C doivent utiliser une méthode de *dpointer.

Y a-t-il quelque chose de plus élégant que de donner dpointer en tant que membre de B et C? Est-il mauvais ?

Answer 1

Dans cette situation, vous devriez probablement passer une référence à B et C au lieu d'un pointeur. Comme @Billy ONeil dit dans his answer, vous devez utiliser un shared_ptr ou un scoped_ptr si possible et approprié (ne peut pas juger sans en savoir plus sur D et dpointer) dans A. En passant une référence à B et C a l'avantage de faire comprendre que ces deux simplement utiliser le D -object, mais ne contrôle pas son cycle de vie, et qu'une instance de D est nécessaire pour utiliser ces classes (avec un pointeur NULL serait être une option). Si B et C appelez seulement const méthodes sur D, vous pouvez même passer une référence const.

Answer 2

Pas directement, mais vous pourriez mettre D à l'intérieur d'un shared_ptr<D>, ce qui atténuerait les maux de tête de gestion de la mémoire que vous pourriez avoir.

Answer 3

struct D; 
struct CommonABC 
{ 
    CommonABC(D * & dpointer) : dpointer(dpointer) {} 
    D * & dpointer; 
}; 
struct C : CommonABC 
{ 
    C (const CommonABC & common) : CommonABC(сommon) {} 
}; 
struct B: CommonABC 
{ 
    B (const CommonABC & common) : CommonABC(сommon), c(common) {} 
    C c; 
}; 
struct A 
{ 
    A() : b(CommonABC(dpointer)) {} 
    D * dpointer; 
    B b; 
}; 

Answer 4

En pratique, j'opterais probablement pour la solution shared_ptr mentionnée ci-dessus. Mais voici une autre façon qui est pas souvent couvert dans la littérature du C, du genre que vous pourriez trouver dans une question d'entrevue ou un test BrainBench:

struct D{ 
    D(int val); 
    void foo(); 
}; 
struct C:private virtual D{ 
    void bar(){ 
    foo(); 
    } 
}; 
struct B:private C,private virtual D{ 
    void car(){ 
    foo(); 
    } 
}; 

struct A:private B,private virtual D{ 
    A(int val):D(val){} 
    void aar(){ 
    car(); 
    foo(); 
    } 

}; 

héritage privé met en œuvre l'a-une relation, tout comme ce qui en fait un membre. La seule différence est que vous ne pouvez en avoir qu'un de chaque type. Dans ce cas, le même objet D est partagé par toutes les classes de la composition.

Mais si vous voulez que les autres puissent comprendre ce que vous faites, utilisez shared_ptrs.