Virtual base class in C++ with example

 

In C++, a virtual base class is a class that is intended to be inherited by multiple classes within an inheritance hierarchy. When a class is declared as a virtual base class, it helps prevent the "diamond problem" (also known as the "deadly diamond of death") that can occur in multiple inheritance scenarios.

The "diamond problem" occurs when a class inherits from two or more classes that have a common base class. It can lead to ambiguity in the way members of the common base class are accessed. Virtual base classes resolve this ambiguity by ensuring that only one instance of the base class is shared among the derived classes.

Here's an example to illustrate the concept of a virtual base class:

cpp
#include <iostream>

class Animal {
public:
    void eat() {
        std::cout << "Animal is eating." << std::endl;
    }
};

class Mammal : virtual public Animal {
public:
    void breathe() {
        std::cout << "Mammal is breathing." << std::endl;
    }
};

class Bird : virtual public Animal {
public:
    void fly() {
        std::cout << "Bird is flying." << std::endl;
    }
};

class Bat : public Mammal, public Bird {
public:
    void sleep() {
        std::cout << "Bat is sleeping." << std::endl;
    }
};

int main() {
    Bat bat;
    bat.eat();     // Calls Animal's eat
    bat.breathe(); // Calls Mammal's breathe
    bat.fly();     // Calls Bird's fly
    bat.sleep();   // Calls Bat's sleep

    return 0;
}

In this example:

1. 1. We have a base class Animal that provides a common functionality, in this case, the eat function.

2. 2. We have two derived classes, Mammal and Bird, which inherit virtually from the Animal class using the virtual keyword. This ensures that there is only one instance of Animal shared among the derived classes.

3. 3. The Bat class inherits from both Mammal and Bird. Since both of these classes have a virtual base class, there is no ambiguity in accessing the Animal class's members. The Bat class can directly access the eat method of the Animal class.

4. 4. In the main function, we create an instance of the Bat class and demonstrate how it can access the eat, breathe, fly, and sleep methods without ambiguity.

Using a virtual base class in multiple inheritance situations helps ensure a clear and unambiguous inheritance hierarchy and resolves potential issues related to the "diamond problem." It ensures that there is only one shared instance of the common base class, making the code more maintainable and reducing potential complications.