Welcome to C++ Programming Tutorial

Pure Virtual Functions

A pure virtual function is a virtual function that has no definition in the base class. It is used to make a class abstract, meaning that you cannot instantiate objects of this class. Any class containing at least one pure virtual function is considered an abstract class.

To declare a pure virtual function, use the syntax virtual returnType functionName() = 0;. Derived classes must override pure virtual functions to become concrete classes that can be instantiated.

Example: Pure Virtual Function

#include <iostream>
using namespace std;

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0; // Pure virtual function
};

class ConcreteDerived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        cout << "Implementation of pure virtual function in ConcreteDerived class" << endl;
    }
};

int main() {
    ConcreteDerived obj;
    obj.pureVirtualFunction(); // Output: Implementation of pure virtual function in ConcreteDerived class

    return 0;
}
                    

Breakdown of the Example:

AbstractBase Class:

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0; // Pure virtual function
};
                    

The AbstractBase class contains a pure virtual function pureVirtualFunction(), making it an abstract class.

ConcreteDerived Class:

class ConcreteDerived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        cout << "Implementation of pure virtual function in ConcreteDerived class" << endl;
    }
};
                    

The ConcreteDerived class inherits from AbstractBase and provides an implementation for the pure virtual function.

Main Function:

int main() {
    ConcreteDerived obj;
    obj.pureVirtualFunction(); // Output: Implementation of pure virtual function in ConcreteDerived class

    return 0;
}
                    

The main() function creates an instance of ConcreteDerived and calls the pureVirtualFunction() method.

The Diamond Problem

The diamond problem is a situation that occurs in multiple inheritance where two classes, ClassB and ClassC, both inherit from a base class ClassA. If a class ClassD inherits from both ClassB and ClassC, ClassD ends up with two copies of ClassA. This leads to ambiguity when accessing members of ClassA.

C++ resolves the diamond problem using virtual inheritance. Virtual inheritance ensures that only one copy of the base class is present in the derived class.

Example: Diamond Problem

#include <iostream>
using namespace std;

class A {
public:
    void display() {
        cout << "Class A" << endl;
    }
};

class B : virtual public A {
};

class C : virtual public A {
};

class D : public B, public C {
};

int main() {
    D obj;
    obj.display(); // Output: Class A

    return 0;
}
                    

Breakdown of the Example:

Class A:

class A {
public:
    void display() {
        cout << "Class A" << endl;
    }
};
                    

Class A contains a member function display().

Class B and Class C:

class B : virtual public A {
};

class C : virtual public A {
};
                    

Classes B and C inherit from Class A using virtual inheritance to avoid multiple copies of Class A.

Class D:

class D : public B, public C {
};
                    

Class D inherits from both B and C. Because of virtual inheritance, there is only one instance of Class A in Class D.

Main Function:

int main() {
    D obj;
    obj.display(); 

    return 0;
}
                    

The display() function from Class A is correctly called through the D object, demonstrating that virtual inheritance resolves the diamond problem.