Nhiều thừa kế cơ sở nhập nhằng lớp

Question

xem xét mã

struct Base{}; 
struct Derived: public Base{}; 

struct A: public Base{}; 

struct B: public A, public Base{}; 

struct C: public A, public Derived{}; // why no ambiguity here? 

int main() {} 

Trình biên dịch (g ++ 5.1) cảnh báo rằng

cảnh báo: cơ sở trực tiếp 'Base' không thể tiếp cận trong 'B' do sự nhập nhằng struct B: public A, public Base{};

Tôi hiểu điều này, Base được nhân đôi trong B.

1. Tại sao không có cảnh báo cho C? Không C được kế thừa từ cả hai số A và Derived, cả hai đều được kế thừa từ Base?

2. Tại sao thêm virtual

   struct Derived: virtual Base{}; 
   

kết quả bây giờ trong cả B và C cảnh báo phát ra, sống trên Wandbox

cảnh báo: cơ sở trực tiếp 'Base' không thể tiếp cận trong 'B' do sự nhập nhằng struct B: public A, public Base{};

cảnh báo: cơ sở trực tiếp 'Base' không thể tiếp cận trong 'C' do sự nhập nhằng struct C: public A, public Derived{};

Answer 1

Trong B, nó không thể đề cập đến các thành viên của Base subobject thừa hưởng trực tiếp. Hãy xem xét:

struct Base { 
    int x; 
}; 

struct B: public A, public Base { 
    void foo() { 
     int& x1 = A::x; // OK 
     int& x2 = x; // ambiguous 
     // no way to refer to the x in the direct base 
    } 
}; 

Trong C đây không phải là vấn đề. Cả hai x 's có thể được gọi bằng tên tiêu chuẩn:

struct C: public A, public Derived { 
    void foo() { 
     int& x1 = A::x; // OK 
     int& x2 = Derived::x; // OK 
    } 
}; 

Vì vậy, các cảnh báo bạn nhận được là một trong đó chỉ có ý nghĩa khi một cơ sở trực tiếp cũng được thừa hưởng thông qua con đường khác.

Đối với câu hỏi thứ hai của bạn, tôi không thể tạo lại cảnh báo bằng C trên Coliru bằng g ++ - 5.1.

Answer 2

Không có cách để truy cập một cách rõ ràng cho các thành viên cơ sở trong "B" trong khi nó có thể trong "C", như minh họa trong đoạn mã sau:

#include <iostream> 

using namespace std; 

struct Base 
{ 
    void print() 
    { 
     cout << "Base" << endl; 
    } 
}; 

struct Derived : public Base {}; 

struct A : public Base 
{ 
    void print() 
    { 
     cout << "A" << endl; 
    } 
}; 

struct B : public A, public Base 
{ 
    void print() 
    { 
     A::print(); 

     //error (ambiguous), no way to access to Base::print => warning 
     //Base::print(); 
    } 
}; 

struct C : public A, public Derived 
{ 
    void print() 
    { 
     A::print(); 
     Derived::print(); // Not Ambiguous, it's the Base inherited by 'Derived' which is used. 
     // Still an error but you can access print indirectly through "Derived" => no warning needed 
     //Base::print(); 
    } 
}; 

int main() 
{ 
    B b; 
    b.print(); 

    C c; 
    c.print(); 

    return 0; 
}