C++ общие объекты

Question

У меня есть четыре класса A, B, C и D.

• Класс A имеет элемент b класса B.
• Класс B имеет член c класса C.

A имеет элемент D* dpointer;

Эта иерархия должен быть сохранен (на самом деле это графический интерфейс с приложением, окна, панели, как A, B и C).

Теперь B и C должны использовать метод от *dpointer.

Есть ли что-то более элегантное, чем предоставление dpointer в качестве члена B и C? Это плохо ?

Answer 1

В этой ситуации вы, вероятно, следует передать ссылку на B и C вместо указателя. Как @Billy ONeil говорит в his answer, вы должны использовать shared_ptr или scoped_ptr, если это возможно и подходит (не можете судить, не зная больше о D и dpointer) в A. Передача ссылки на B и C имеет то преимущество, что ясно, что эти два просто использовать в D -объекте, но не контролировать его жизненный цикл, и что экземпляр D требуется использовать эти классы (с указателем NULL будет быть вариантом). Если B и C звоните только const методам на D, вы даже можете передать ссылку на const.

Answer 2

Не напрямую, но вы можете поместить D внутри shared_ptr<D>, что облегчит любые головные боли управления памятью, которые могут возникнуть у вас.

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

На практике я бы выбрал решение shared_ptr, упомянутое выше. Но вот еще один способ, который часто не рассматривается в С ++ литературе подобного можно найти в интервью вопрос или тест 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(); 
    } 

}; 

частное наследование реализует Has-отношения, так же, как делает это участник. Единственное отличие состоит в том, что вы можете иметь только один тип. В этом случае один и тот же объект D разделяется всеми классами в композиции.

Но если вы хотите, чтобы другие могли понять, что вы делаете, перейдите с shared_ptrs.