How do virtual functions work with multiple inheritance in C++?

When a class inherits from multiple base classes that have virtual functions, the virtual function calls are resolved based on the order of inheritance and the specific class hierarchy.

In C++, when a class inherits from multiple base classes, it can potentially inherit multiple implementations of the same virtual function. To resolve this ambiguity, the compiler uses a mechanism called "virtual function table" (vtable) for each class.

Each class that contains virtual functions has its own vtable, which is an array of function pointers. The vtable contains entries for all the virtual functions declared in the class and its base classes. When a class inherits from multiple base classes, its vtable is constructed by concatenating the vtables of its base classes.

Here's an example to illustrate how virtual function calls are resolved in multiple inheritance:

1#include <iostream>
2
3class BaseA {
4public:
5  virtual void foo() {
6    std::cout << "BaseA::foo()\n"; }
7};
8
9class BaseB {
10public:
11  virtual void foo() {
12    std::cout << "BaseB::foo()\n"; }
13  virtual void bar() {
14    std::cout << "BaseB::bar()\n"; }
15};
16
17class Derived : public BaseA, public BaseB {
18public:
19  void foo() override {
20    std::cout << "Derived::foo()\n"; }
21};
22
23int main() {
24  Derived derived;
25  BaseA* baseA = &derived;
26  BaseB* baseB = &derived;
27
28  baseA->foo();
29  baseB->foo();
30  baseB->bar();
31}

1Derived::foo()
2Derived::foo()
3BaseB::bar()

In this example, the Derived class inherits from both BaseA and BaseB. Both base classes have their own virtual function foo(), and BaseB also has a virtual function bar().

When baseA->foo() is called, the compiler looks up the vtable of BaseA and finds the entry for foo(). Since Derived overrides foo(), the Derived::foo() implementation is called.

Similarly, when baseB->foo() is called, the compiler looks up the vtable of BaseB and finds the entry for foo(). Again, since Derived overrides foo(), the Derived::foo() implementation is called.

When baseB->bar() is called, the compiler looks up the vtable of BaseB and finds the entry for bar(). Since Derived doesn't override bar(), the BaseB::bar() implementation is called.

It's important to note that if a derived class inherits from multiple base classes and does not override a virtual function that is present in multiple base classes, the compiler will generate an ambiguity error. To resolve this, you need to explicitly specify which base class's implementation should be used using scope resolution.

1class Derived : public BaseA, public BaseB {
2 public:
3  void foo() override {
4    // Explicitly call BaseA's implementation
5    BaseA::foo();
6  }
7};

In summary, when a class inherits from multiple base classes with virtual functions, the virtual function calls are resolved based on the vtable and the specific class hierarchy. The derived class can override the virtual functions, and the most derived implementation will be called.