'Base directa inaccesible' causada por herencia múltiple

Question

Alerta de alerta: Quizás una pregunta estúpida. :)

#include <iostream> 

using namespace std; 

class Base 
{ 
    public: 
     virtual void YourMethod(int) const = 0; 
}; 

class Intermediate : private Base 
{ 
    public: 
     virtual void YourMethod(int i) const 
     { 
      cout << "Calling from Intermediate" << i << "\n"; 
     } 
}; 

class Derived : private Intermediate, public Base 
{ 
    public: 
     void YourMethod(int i) const 
     { 
      cout << "Calling from Derived : " << i << "\n"; 
     } 
}; 

int main() 
{ 
} 

Puede alguien explicar para mí por qué esto arroja el compilador advertencia:

main.cpp:21: warning: direct base ‘Base’ inaccessible in ‘Derived’ due to ambiguity 

Ahora, entiendo que no hay forma en que este código funcionará. Quiero saber por qué. Base es privado a Intermediate por lo que no debería ser visible para Derived a través de Intermediate. Entonces, ¿de dónde viene la ambigüedad? En constructor?

Answer 1

Esto no tiene nada que ver con las funciones de anulación. Tiene que ver con las conversiones. Realmente no tiene que ver con la accesibilidad (es decir, "privada" o tal) directamente tampoco. Aquí está un ejemplo más simple

struct A { int a; }; 
struct B : A { }; 
struct C : B, A { }; // direct A can't be referred to! 

Se puede hacer referencia a la A objeto indirecto convirtiendo en primer lugar a B y luego a A:

B *b = &somec; 
A *a = b; 

No se puede hacer por ejemplo con la directa Un objeto. Si intenta convertir directamente a A, tendrá dos posibilidades. Se deduce que es imposible hacer referencia a los miembros de datos no estáticos del objeto directo A dado un objeto Derived.

Tenga en cuenta que la accesibilidad es ortogonal a la visibilidad. Algo puede ser accesible aunque no sea visible (por ejemplo, refiriéndolo a un nombre calificado), y algo puede ser visible aunque no sea accesible. Incluso si todas las derivaciones anteriores se declararan private, el problema seguiría apareciendo: El acceso se verifica por última vez; no afectará la búsqueda de nombres ni las reglas de conversión.

Además, cualquiera puede convertir a una clase base privada no ambigua con un comportamiento definido (el estándar de C++ hace una excepción para esto) usando un molde de estilo C, aunque normalmente no se le otorgaría acceso para hacerlo. Y luego todavía hay amigos y la clase en sí que puede convertir libremente.

Answer 2

La respuesta de Johannes cubre los hechos básicos. Pero hay un poco más. Por lo tanto, considere

struct Base 
{ 
    Base(int) {} 
    void foo() const {} 
}; 

struct Intermediate: Base 
{ 
    Intermediate(int x) 
     : Base(x) 
    {} 
}; 

struct Derived: Intermediate, Base 
{ 
    Derived(int x) 
     : Intermediate(x) 
     , Base(x)   // OK 
    {} 
}; 

int main() 
{ 
    Derived o(667); 
    o.foo();    // !Oops, ambiguous. 
    o.Base::foo();   // !Oops, still ambiguous. 
} 

Cuando compilo consigo, ya que por ahora (después de la respuesta Johannes') que se puede esperar,

 
C:\test> gnuc x.cpp 
x.cpp:15: warning: direct base 'Base' inaccessible in 'Derived' due to ambiguity 
x.cpp: In function 'int main()': 
x.cpp:25: error: request for member 'foo' is ambiguous 
x.cpp:4: error: candidates are: void Base::foo() const 
x.cpp:4: error:     void Base::foo() const 
x.cpp:26: error: 'Base' is an ambiguous base of 'Derived' 

C:\test> msvc x.cpp 
x.cpp 
x.cpp(15) : warning C4584: 'Derived' : base-class 'Base' is already a base-class of 'Intermediate' 
     x.cpp(2) : see declaration of 'Base' 
     x.cpp(7) : see declaration of 'Intermediate' 
x.cpp(25) : error C2385: ambiguous access of 'foo' 
     could be the 'foo' in base 'Base' 
     or could be the 'foo' in base 'Base' 
x.cpp(25) : error C3861: 'foo': identifier not found 

C:\test> _ 

Cómo resolver dependerá de si todo está bien con un solo sub -objeto de la clase Base (como es el caso cuando Base es una interfaz pura), o Intermediate realmente requiere su propio sub-objeto Base.

El último caso, dos sub-objetos Base, probablemente no es lo que quieres, pero si quieres eso, entonces una cura es introducir otra clase intermedia, por ejemplo, ResolvableBase.

térmica:

struct Base 
{ 
    Base(int) {} 
    void foo() const {} 
}; 

struct Intermediate: Base 
{ 
    Intermediate(int x) 
     : Base(x) 
    {} 
}; 

struct ResolvableBase: Base 
{ 
    ResolvableBase(int x): Base(x) {} 
}; 

struct Derived: Intermediate, ResolvableBase 
{ 
    Derived(int x) 
     : Intermediate(x) 
     , ResolvableBase(x) 
    {} 
}; 

int main() 
{ 
    Derived o(667); 
    o.ResolvableBase::foo(); // OK. 
} 

En el primer caso, donde por ejemplo,Base es una interfaz y solo se necesita un subobjeto Base, puede usar la herencia virtual.

La herencia virtual generalmente agrega un poco de sobrecarga de tiempo de ejecución, y Visual C++ no es muy aficionado a ella.

sino que le permite "Heredar" una implementación de una interfaz, como en Java y C#:

struct Base 
{ 
    Base(int) {} 
    virtual void foo() const = 0; 
}; 

struct Intermediate: virtual Base 
{ 
    Intermediate(int x) 
     : Base(x) 
    {} 
    void foo() const {}  // An implementation of Base::foo 
}; 

struct Derived: virtual Base, Intermediate 
{ 
    Derived(int x) 
     : Base(x) 
     , Intermediate(x) 
    {} 
}; 

int main() 
{ 
    Derived o(667); 
    o.foo(); // OK. 
} 

Sutileza: Me cambió el orden de la lista de herencia con el fin de evitar g ++ sillywarnings sobre el orden de inicialización.

Molesto: Visual C++ emite un tonto C4250 sobre la herencia (de la implementación) a través de la dominación. Es como "advertencia: estás usando una función principal estándar". Oh, bueno, solo apágalo.

Saludos & HTH.,