Что такое виртуальный базовый класс в C++?

Это означает, что вызов виртуальной функции будет перенаправлен в «правильный» класс.

C++ FAQ Lite FTW.

Короче говоря, он часто используется в сценариях множественного наследования, где формируется «ромбовидная» иерархия. Виртуальное наследование затем устранит неоднозначность, созданную в нижнем классе, когда вы вызываете функцию в этом классе, и функция должна быть разрешена либо в класс D1, либо в D2 выше этого нижнего класса. См. Схему и подробности в Пункт FAQ.

Он также используется в родственная делегация, мощной функции (но не для слабонервных). См. FAQ по это.

Также см. Пункт 40 в Эффективном C++ 3-м издании (43 во 2-м издании).

Виртуальные базовые классы, используемые в виртуальном наследовании, являются способом предотвращения появления нескольких «экземпляров» данного класса в иерархии наследования при использовании множественного наследования.

Рассмотрим следующий сценарий:

class A { public: void Foo() {} };
class B : public A {};
class C : public A {};
class D : public B, public C {};

Вышеупомянутая иерархия классов приводит к «страшному бриллианту», который выглядит следующим образом:

  A
 / \
B   C
 \ /
  D

Экземпляр D будет составлен из B, который включает A, и C, который также включает A. Итак, у вас есть два «экземпляра» (из-за отсутствия лучшего выражения) A.

Когда у вас есть этот сценарий, у вас есть возможность двусмысленности. Что происходит, когда вы это делаете:

D d;
d.Foo(); // is this B's Foo() or C's Foo() ??

Виртуальное наследование призвано решить эту проблему. Когда вы указываете virtual при наследовании ваших классов, вы сообщаете компилятору, что вам нужен только один экземпляр.

class A { public: void Foo() {} };
class B : public virtual A {};
class C : public virtual A {};
class D : public B, public C {};

Это означает, что в иерархию включен только один «экземпляр» A. Следовательно

D d;
d.Foo(); // no longer ambiguous

Это краткое изложение. Для получения дополнительной информации прочтите это и это. Также доступен хороший пример здесь.

A virtual base class is a class that cannot be instantiated : you cannot create direct object out of it.

Я думаю, вы путаете две очень разные вещи. Виртуальное наследование - это не то же самое, что абстрактный класс. Виртуальное наследование изменяет поведение вызовов функций; иногда он разрешает вызовы функций, которые в противном случае были бы неоднозначными, иногда он откладывает обработку вызовов функций классу, отличному от того, который можно было бы ожидать при невиртуальном наследовании.

Вы немного запутались. Не знаю, путаете ли вы какие-то концепции.

У вас нет виртуального базового класса в вашем OP. У вас просто базовый класс.

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

Базовый класс с чистой виртуальной функцией не создается. для этого требуется синтаксис, к которому приходит Пол. Обычно он используется для того, чтобы производные классы определяли эти функции.

Я не хочу больше объяснять это, потому что я не совсем понимаю, о чем вы спрашиваете.

Виртуальные классы нет такие же, как виртуальное наследование. Виртуальные классы, которые вы не можете создать, виртуальное наследование - это совсем другое.

Википедия описывает это лучше, чем я. http://en.wikipedia.org/wiki/Virtual_inheritance

Я хотел бы добавить к любезным разъяснениям О.Джея.

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

Вместо того, чтобы разбивать алмаз виртуально, вы можете добавить еще один слой к алмазу, чтобы получить что-то вроде этого:

   B
  / \
D11 D12
 |   |
D21 D22
 \   /
  DD

Ни один из классов не наследуется виртуально, все наследуются публично. Классы D21 и D22 затем скроют виртуальную функцию f (), что неоднозначно для DD, возможно, объявив функцию частной. Каждый из них определяет функцию-оболочку, f1 () и f2 () соответственно, каждый из которых вызывает локальный класс (частный) f (), тем самым разрешая конфликты. Класс DD вызывает f1 (), если он хочет D11 :: f () и f2 (), если он хочет D12 :: f (). Если вы определите встроенные обертки, вы, вероятно, получите нулевые накладные расходы.

Конечно, если вы можете изменить D11 и D12, вы можете проделать тот же трюк внутри этих классов, но часто это не так.

О раскладке памяти

Кстати, проблема с Dreaded Diamond заключается в том, что базовый класс присутствует несколько раз. Итак, при обычном наследовании вы считаете, что у вас есть:

  A
 / \
B   C
 \ /
  D

Но в макете памяти у вас есть:

A   A
|   |
B   C
 \ /
  D

Это объясняет, почему при вызове D::foo() возникает проблема двусмысленности. Но проблема настоящий возникает, когда вы хотите использовать переменную-член A. Например, допустим, у нас есть:

class A
{
    public :
       foo() ;
       int m_iValue ;
} ;

Когда вы попытаетесь получить доступ к m_iValue из D, компилятор будет протестовать, потому что в иерархии он увидит два m_iValue, а не один. И если вы измените один, скажем, B::m_iValue (это родительский элемент A::m_iValue для B), C::m_iValue не будет изменен (это родительский элемент A::m_iValue для C).

Здесь пригодится виртуальное наследование, так как с его помощью вы вернетесь к истинной ромбовидной схеме не только с одним методом foo(), но и с одним и только одним m_iValue.

Что может пойти не так?

Представлять себе:

• A имеет некоторые базовые функции.
• B добавляет к нему какой-то крутой массив данных (например)
• C добавляет к нему такую ​​классную функцию, как шаблон наблюдателя (например, на m_iValue).
• D наследуется от B и C и, следовательно, от A.

При нормальном наследовании изменение m_iValue из D неоднозначно, и эту проблему необходимо решить. Даже если это так, внутри m_iValues есть два D, поэтому вам лучше запомнить это и обновить их одновременно.

С виртуальным наследованием можно изменить m_iValue из D ... Но ... Допустим, у вас есть D. Через его интерфейс C вы подключили наблюдателя. А через интерфейс B вы обновляете классный массив, побочным эффектом которого является прямое изменение m_iValue ...

Поскольку изменение m_iValue выполняется напрямую (без использования метода виртуального доступа), наблюдатель, "прослушивающий" через C, не будет вызываться, потому что код, реализующий прослушивание, находится в C, а B не знает об этом. .

Вывод

Если у вас есть ромб в вашей иерархии, это означает, что у вас есть 95% вероятность того, что вы сделали что-то не так с указанной иерархией.

В дополнение к тому, что уже было сказано о множественном и виртуальном наследовании, в журнале доктора Добба есть очень интересная статья: Множественное наследование считается полезным

Для объяснения множественного наследования с помощью виртуальных баз требуется знание объектной модели C++. И четкое объяснение темы лучше всего делать в статье, а не в поле для комментариев.

Лучшее, читаемое объяснение, которое я нашел, разрешившее все мои сомнения по этому поводу, - это статья: http://www.phpcompiler.org/articles/virtualinheritance.html

Вам действительно не нужно будет больше ничего читать по этой теме (если вы не являетесь автором компилятора) после прочтения этого ...

Пример использования исполняемого алмазного наследования

В этом примере показано, как использовать виртуальный базовый класс в типичном сценарии: для решения проблем наследования алмаза.

Рассмотрим следующий рабочий пример:

main.cpp

#include <cassert>

class A {
    public:
        A(){}
        A(int i) : i(i) {}
        int i;
        virtual int f() = 0;
        virtual int g() = 0;
        virtual int h() = 0;
};

class B : public virtual A {
    public:
        B(int j) : j(j) {}
        int j;
        virtual int f() { return this->i + this->j; }
};

class C : public virtual A {
    public:
        C(int k) : k(k) {}
        int k;
        virtual int g() { return this->i + this->k; }
};

class D : public B, public C {
    public:
        D(int i, int j, int k) : A(i), B(j), C(k) {}
        virtual int h() { return this->i + this->j + this->k; }
};

int main() {
    D d = D(1, 2, 4);
    assert(d.f() == 3);
    assert(d.g() == 5);
    assert(d.h() == 7);
}

Скомпилируйте и запустите:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Если мы удалим virtual в:

class B : public virtual A

мы получили бы стену ошибок о том, что GCC не может разрешить элементы и методы D, которые были унаследованы дважды через A:

main.cpp:27:7: warning: virtual base ‘A’ inaccessible in ‘D’ due to ambiguity [-Wextra]
   27 | class D : public B, public C {
      |       ^
main.cpp: In member function ‘virtual int D::h()’:
main.cpp:30:40: error: request for member ‘i’ is ambiguous
   30 |         virtual int h() { return this->i + this->j + this->k; }
      |                                        ^
main.cpp:7:13: note: candidates are: ‘int A::i’
    7 |         int i;
      |             ^
main.cpp:7:13: note:                 ‘int A::i’
main.cpp: In function ‘int main()’:
main.cpp:34:20: error: invalid cast to abstract class type ‘D’
   34 |     D d = D(1, 2, 4);
      |                    ^
main.cpp:27:7: note:   because the following virtual functions are pure within ‘D’:
   27 | class D : public B, public C {
      |       ^
main.cpp:8:21: note:    ‘virtual int A::f()’
    8 |         virtual int f() = 0;
      |                     ^
main.cpp:9:21: note:    ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
main.cpp:34:7: error: cannot declare variable ‘d’ to be of abstract type ‘D’
   34 |     D d = D(1, 2, 4);
      |       ^
In file included from /usr/include/c++/9/cassert:44,
                 from main.cpp:1:
main.cpp:35:14: error: request for member ‘f’ is ambiguous
   35 |     assert(d.f() == 3);
      |              ^
main.cpp:8:21: note: candidates are: ‘virtual int A::f()’
    8 |         virtual int f() = 0;
      |                     ^
main.cpp:17:21: note:                 ‘virtual int B::f()’
   17 |         virtual int f() { return this->i + this->j; }
      |                     ^
In file included from /usr/include/c++/9/cassert:44,
                 from main.cpp:1:
main.cpp:36:14: error: request for member ‘g’ is ambiguous
   36 |     assert(d.g() == 5);
      |              ^
main.cpp:9:21: note: candidates are: ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
main.cpp:24:21: note:                 ‘virtual int C::g()’
   24 |         virtual int g() { return this->i + this->k; }
      |                     ^
main.cpp:9:21: note:                 ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
./main.out

Проверено на GCC 9.3.0, Ubuntu 20.04.