Virtual inheritance
From Wikipedia, the free encyclopedia
- For inheritance of virtual functions, see virtual function.
In the C++ programming language, virtual inheritance is a kind of inheritance that solves some of the problems caused by multiple inheritance (particularly the "diamond problem") by clarifying ambiguity over which ancestor class members to use. It is used when inheritance is representing restrictions of a set rather than composition of parts. A multiply-inherited base class is denoted as virtual with the virtual
keyword.
Contents |
[edit] The problem
Consider the following class hierarchy.
class Animal { public: virtual void eat(); }; class Mammal : public Animal { public: virtual Color getHairColor(); }; class WingedAnimal : public Animal { public: virtual void flap(); }; // A bat is a winged mammal class Bat : public Mammal, public WingedAnimal {}; Bat bat;
But how does bat
eat()
? As declared above, a call to bat.eat()
is ambiguous. One would have to call either bat.WingedAnimal::Animal::eat()
or bat.Mammal::Animal::eat()
. The problem is that semantics of conventional multiple inheritance do not model reality. In a sense, an Animal
is only an Animal
once; a Bat
is a Mammal
and a WingedAnimal
, but the Animal
ness of a Bat
's Mammal
ness is the same Animal
ness as that of its WingedAnimal
ness.
This situation is sometimes referred to as diamond inheritance and is a problem that virtual inheritance works, in part, to solve.
[edit] Class representation
Before going further it is helpful to consider how classes are represented in C++. In particular, inheritance is simply a matter of putting parent and child class one after the other in memory. Thus Bat is really (Animal,Mammal,Animal,WingedAnimal,Bat) which makes Animal duplicated, causing the ambiguity.
[edit] Solution
We can redeclare our classes as follows:
// Two classes virtually inheriting Animal: class Mammal : public virtual Animal { public: virtual Color getHairColor(); }; class WingedAnimal : public virtual Animal { public: virtual void flap(); }; // A bat is still a winged mammal class Bat : public Mammal, public WingedAnimal {};
Now the Animal
portion of Bat::WingedAnimal
is the same Animal
as the one used by Bat::Mammal
, which is to say that a Bat
has only one Animal
in its representation and so a call to Bat::eat()
is unambiguous.
This is implemented by providing Mammal
and WingedAnimal
with a vtable pointer since, e.g., the memory offset between the beginning of a Mammal
and of its Animal
part is unknown until runtime. Thus Bat becomes (vtable*,Mammal,vtable*,WingedAnimal,Bat,Animal). Two vtable pointers per object, so the object size increased by two pointers, but now there is only one Animal and no ambiguity. There are two vtables pointers: one per inheritance hierarchy that virtually inherits Animal: One for Mammal and one for WingedAnimal. All objects of type Bat will have the same vtable *'s, but each Bat object will contain its own unique Animal object. If another class inherits Mammal, such as Squirrel, then the vtable* in the Mammal object in a Squirrel will be different from the vtable* in the Mammal object in a Bat, although they can still be essentially the same in the special case that the squirrel part of the object has the same size as the Bat part, because then the distance from the Mammal to the Animal part is the same. The vtables are not really the same, but all essential information in them (the distance) is.