Dlaczego nie ma dwuznaczności w tym wzorze diamentu?

Question

#include <iostream> 
using namespace std; 

class A    { public: void eat(){ cout<<"A";} }; 
class B: public A { public: void eat(){ cout<<"B";} }; 
class C: public A { public: void eat(){ cout<<"C";} }; 
class D: public B,C { public: void eat(){ cout<<"D";} }; 

int main(){ 
    A *a = new D(); 
    a->eat(); 
} 

Nie jestem pewien, czy to się nazywa problemem diamentowym, ale dlaczego to nie działa?

Podałem definicję dla eat() dla D. Nie trzeba więc używać ani kopii B ani C (więc nie powinno być problemu).

Kiedy powiedziałem, a->eat() (pamiętaj eat() nie jest wirtualny), jest tylko jednym z możliwych eat() zadzwonić, że od A.

Dlaczego więc mogę dostać ten błąd:

'A' is an ambiguous base of 'D'

---

Co dokładnie ma na myśli A *a = new D(); do kompilatora ??

i

Dlaczego nie ten sam problem występuje podczas korzystania D *d = new D();?

Answer 1

Wyobraźmy sobie nieco inny scenariusz

class A    { protected: int a; public: void eat(){ a++; cout<<a;} }; 
class B: public A { public: void eat(){ cout<<a;} }; 
class C: public A { public: void eat(){ cout<<a;} }; 
class D: public B,C { public: void eat(){ cout<<"D";} }; 

int main(){ 
    A *a = new D(); 
    a->eat(); 
} 

Jeśli to się uda, to zwiększa zawartość a w B lub a w C? Dlatego jest niejednoznaczny.this wskaźnik i nie będących statyczny element danych jest różna dla dwóch A podobiektów (z których jeden jest zawarty w B podobiektu, a drugi przez C podobiektu). Spróbuj zmienić swój kod tak i będzie działać (w który kompiluje i drukuje „A”)

class A    { public: void eat(){ cout<<"A";} }; 
class B: public A { public: void eat(){ cout<<"B";} }; 
class C: public A { public: void eat(){ cout<<"C";} }; 
class D: public B, public C { public: void eat(){ cout<<"D";} }; 

int main(){ 
    A *a = static_cast<B*>(new D()); 
     // A *a = static_cast<C*>(new D()); 
    a->eat(); 
} 

Że wezwie eat na A podobiektu z B i C odpowiednio.

Answer 2

Wyniki diament w dwóch instancji w obiekcie D, a to nie jest jednoznaczne, który z nich odnoszą się do - trzeba użyć wirtualnego dziedziczenie aby rozwiązać ten problem:

class B: virtual public A { public: void eat(){ cout<<"B";} }; 
class C: virtual public A { public: void eat(){ cout<<"C";} }; 

zakładając, że rzeczywiście tylko chciał jeden egzemplarz. Zakładam również naprawdę oznaczało:

class D: public B, public C { public: void eat(){ cout<<"D";} }; 

Answer 3

Błąd dostajesz nie pochodzi wywołanie eat() - to pochodzący z linii wcześniej. To właśnie upcast tworzy niejednoznaczność. Jak wskazuje Neil Butterworth, w twoim D są dostępne dwie kopie A, a kompilator nie wie, który z nich ma być oznaczony jako a.

Answer 4

Należy zauważyć, że błąd kompilacji występuje w "A * a = new D();" linii, a nie na wezwanie do "jedzenia".

Problem polega na tym, że z powodu dziedziczenia innego niż wirtualne, kończy się to na klasie A dwa razy: raz przez B i raz przez C. Jeśli na przykład dodasz element m do A, to D ma dwa z nich : B :: m, i C :: m.

Czasami naprawdę chcesz mieć A dwukrotnie na wykresie wyprowadzenia, w którym to przypadku zawsze musisz wskazać, o którym mówisz. W D możesz odnieść się do B :: m i C :: m osobno.

Czasami naprawdę potrzebujesz tylko jednego A, w takim przypadku musisz użyć virtual inheritance.

Answer 5

Dla prawdziwie nietypowej sytuacji, odpowiedź Neil jest faktycznie źle (przynajmniej częściowo).

Z dziedziczeniem wirtualnym otrzymujesz dwie oddzielne kopie A w ostatecznym obiekcie.

„diament” Wyniki w jednym egzemplarzu z A w końcowej przedmiotu i jest produkowany przez użyciu wirtualny dziedziczenia:

Ponieważ „diament” oznacza nie tylko jeden kopia A w końcowej przedmiotu, odniesienie do A produkuje żadnych niejasności. Bez dziedziczenia wirtualnego odniesienie do A może odnosić się do jednego z dwóch różnych obiektów (ten po lewej lub ten po prawej na schemacie).

Answer 6

Chcecie: (Osiągalna z wirtualnego dziedziczenia)

  D
 /\
B   C
  \ /
  A

A nie: (Co dzieje się bez wirtualnego dziedziczenia)

    D
  /  \
  B   C
  |     |
  A   A

Wirtualne dziedziczenie oznacza, że ​​nie będzie tylko 1 instancja klasy bazowej A nie 2.

Twój Typ D musiałby 2 vtable wskaźniki (można je zobaczyć w pierwszym rysunku), po jednym dla B i jeden dla C który praktycznie dziedziczą A. D Rozmiar obiektu został zwiększony, ponieważ przechowuje teraz 2 wskaźniki; jednak teraz jest tylko jeden A.

Tak więc B::A i C::A są takie same i dlatego nie może być żadnych niejednoznacznych połączeń od D. Jeśli nie używasz wirtualnego dziedziczenia, masz drugi diagram powyżej. Każde wezwanie do członka A staje się niejednoznaczne i musisz określić, którą ścieżkę chcesz podjąć.

Wikipedia has another good rundown and example here