«Недоступная прямая база», вызванная множественным наследованием

Это не имеет ничего общего с переопределяющими функциями. Это связано с конверсиями. На самом деле это не имеет прямого отношения к доступности (то есть «частной» или тому подобное). Вот более простой пример

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

Вы можете обратиться к косвенному объекту A, сначала преобразовав его в B, а затем в A:

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

Вы не можете сделать это с прямым объектом A. Если вы попытаетесь напрямую преобразовать в A, у вас будет две возможности. Из этого следует, что невозможно ссылаться на нестатические элементы данных прямого объекта A при наличии объекта Derived.

Обратите внимание, что доступность ортогональна видимости. Что-то может быть доступно, даже если оно невидимо (например, если обратиться к нему по полному имени), а что-то может быть видно, даже если оно недоступно. Даже если бы все вышеперечисленные производные были объявлены private, проблема все равно обнаружилась бы: доступ проверяется в последнюю очередь - это не повлияет на поиск имени или правила преобразования.

Кроме того, любой может выполнить приведение к однозначному частному базовому классу с определенным поведением (стандарт C++ делает для этого исключение), используя приведение в стиле C, даже если обычно доступ для этого не предоставляется. А тут еще друзья и сам класс, которые могли свободно конвертировать.

Ответ Йоханнеса охватывает основные факты. Но есть еще кое-что. Итак, рассмотрим

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.
}

Когда я компилирую, я получаю, как и следовало ожидать (после ответа Йоханнеса),

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> _

Способ разрешения зависит от того, все ли в порядке с одним подобъектом класса Base (как в случае, когда Base является чистым интерфейсом), или Intermediate действительно требует своего собственного подобъекта Base.

Последний случай, два подобъекта Base, вероятно, не то, что вам нужно, но если вы этого хотите, то одно из решений состоит в том, чтобы ввести еще один промежуточный класс, скажем, ResolvableBase.

Нравится:

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.
}

В первом случае, где, например. Base — это интерфейс и нужен только один подобъект Base, вы можете использовать виртуальное наследование.

Виртуальное наследование обычно добавляет некоторые накладные расходы во время выполнения, и Visual C++ не слишком любит его.

Но он позволяет «наследовать» реализацию интерфейса, как в Java и 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.
}

Тонкость: я изменил порядок списка наследования, чтобы избежать глупых предупреждений g++ о порядке инициализации.

Раздражение: Visual C++ выдает глупое предупреждение C4250 о наследовании (реализации) через доминирование. Это как "предупреждение: вы используете стандартную основную функцию". Ну, просто выключи.

Ура и чт.,