Virtual inheritance

<h2 id="the-solution">The solution</h2>
<p>We can re-declare our classes as follows:
</p>
struct Animal {
    virtual ~Animal() = default;
    virtual void Eat() {}
};

// Two classes virtually inheriting Animal:
struct Mammal: virtual Animal {
    virtual void Breathe() {}
};

struct WingedAnimal: virtual Animal {
    virtual void Flap() {}
};

// A bat is still a winged mammal
struct Bat: Mammal, WingedAnimal {};

<p>The Animal portion of Bat::WingedAnimal is now the <i>same</i> Animal instance as the one used by Bat::Mammal, which is to say that a Bat has only one, shared, Animal instance in its representation and so a call to Bat::Eat is unambiguous. Additionally, a direct cast from Bat to Animal is also unambiguous, now that there exists only one Animal instance which Bat could be converted to.
</p><p>The ability to share a single instance of the Animal parent between Mammal and WingedAnimal is enabled by recording the memory offset between the Mammal or WingedAnimal members and those of the base Animal within the derived class. However this offset can in the general case only be known at runtime, thus Bat must become (vpointer, Mammal, vpointer, WingedAnimal, Bat, Animal). There are two <a href="/facts/Vtable/rFISodUl">vtable</a> pointers, one per inheritance hierarchy that virtually inherits Animal. In this example, one for Mammal and one for WingedAnimal. The object size has therefore increased by two pointers, but now there is only one Animal and no ambiguity. All objects of type Bat will use the same vpointers, but each Bat object will contain its own unique Animal object. If another class inherits from Mammal, such as Squirrel, then the vpointer in the Mammal part of Squirrel will generally be different to the vpointer in the Mammal part of Bat though they may happen to be the same if the Squirrel class is the same size as Bat.
</p>
<h3>Additional Example of Several Ancestors</h3>
<p>This example to illustrates a case where base class A has a constructor variable msg and an additional ancestor E is derived from grandchild class D.  
</p>
  A  
 / \  
B   C  
 \ /  
  D 
  |
  E
<p>
Here, A must be constructed in both D and E. Further, inspection of the variable msg illustrates how class A becomes a direct base class of its deriving class, as opposed to a base class of any intermediate deriving classed between A and the final deriving class. The code below may be explored interactively <a href="https://godbolt.org/z/ed95e9Yvc">here</a>.</p>#include <string>
#include <iostream>

class A { 
    private: 
        std::string _msg; 
    public:
        A(std::string x): _msg(x) {} 
        void test(){ std::cout<<"hello from A: "<<_msg <<"\n"; } 
};

// B,C inherit A virtually
class B: virtual public A   { public: B():A("b"){}  }; 
class C: virtual public A   { public: C():A("c"){}  };

// since B,C inherit A virtually, A must be constructed in each child
// B() and C() constructors can be omitted
class D: public         B,C { public: D():A("d_a"),B(),C(){}  }; 
// D() constructor omitted
class E: public         D   { public: E():A("e_a"){}  };

// breaks without constructing A
// class D: public      B,C { public: D():B(),C(){}  };

// breaks without constructing A
//class E: public       D   { public: E():D(){}  };

int main(int argc, char ** argv){
    D d; 
    d.test(); 
    // prints: "hello from A: d_a"

E e; 
    e.test(); 
    // prints: "hello from A: e_a"
}

<h4>Pure Virtual Methods</h4><p>
Suppose a pure virtual method is defined in the base class. If a deriving class inherits the base class virtually, then the pure virtual method does not need to be defined in that deriving class. However, if the deriving class does not inherit the base class virtually, then all virtual methods must be defined. The code below may be explored interactively <a href="https://godbolt.org/z/3nrejWfEW">here</a>.</p>#include <string>
#include <iostream>

class A                     { 
    protected: 
        std::string _msg; 
    public:
        A(std::string x): _msg(x) {} 
        void test(){ std::cout<<"hello from A: "<<_msg <<"\n"; } 
        virtual void pure_virtual_test() = 0;
};

// since B,C inherit A virtually, the pure virtual method pure_virtual_test doesn't need to be defined
class B: virtual public A   { public: B(std::string x):A("b"){}  }; 
class C: virtual public A   { public: C(std::string x):A("c"){}  };

// since B,C inherit A virtually, A must be constructed in each child
// however, since D does not inherit B,C virtually, the pure virtual method in A *must be defined*
class D: public B,C { 
    public: 
        D(std::string x):A("d_a"),B("d_b"),C("d_c"){}
        void pure_virtual_test() override { std::cout<<"pure virtual hello from: "<<_msg <<"\n"; }
};

// it is not necessary to redefine the pure virtual method after the parent defines it
class E: public D { 
    public: 
    E(std::string x):A("e_a"),D("e_d"){}  
};

int main(int argc, char ** argv){
    D d("d");
    d.test(); // hello from A: d_a
    d.pure_virtual_test(); // pure virtual hello from: d_a

E e("e"); 
    e.test(); // hello from A: e_a
    e.pure_virtual_test(); // pure virtual hello from: e_a
}

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Milea, Andrei. "Solving the Diamond Problem with Virtual Inheritance". Cprogramming.com. Retrieved 2010-03-08. One of the problems that arises due to multiple inheritance is the diamond problem. A classical illustration of this is given by Bjarne Stroustrup (the creator of C++) in the following example: <a href="http://www.cprogramming.com/tutorial/virtual_inheritance.html" target="_blank">http://www.cprogramming.com/tutorial/virtual_inheritance.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>McArdell, Ralph (2004-02-14). "C++/What is virtual inheritance?". All Experts. Archived from the original on 2010-01-10. Retrieved 2010-03-08. This is something you find may be required if you are using multiple inheritance. In that case it is possible for a class to be derived from other classes which have the same base class. In such cases, without virtual inheritance, your objects will contain more than one subobject of the base type the base classes share. Whether this is what is the required effect depends on the circumstances. If it is not then you can use virtual inheritance by specifying virtual base classes for those base types for which a whole object should only contain one such base class subobject. <a href="https://web.archive.org/web/20100110180819/http://en.allexperts.com/q/C-1040/virtual-inheritance.htm" target="_blank">https://web.archive.org/web/20100110180819/http://en.allexperts.com/q/C-1040/virtual-inheritance.htm</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
</ol>

Virtual inheritance open-in-new

Virtual inheritance