Virtual Destructors and Abstract Classes in C++

Virtual Destructors

A virtual destructor is used to ensure that the destructor of a derived class is called when an object is deleted through a base class pointer. Without a virtual destructor, deleting a derived class object through a base class pointer results in undefined behavior, as only the base class destructor is called.

To declare a virtual destructor, use the syntax virtual ~DestructorName(); in the base class. This ensures that the derived class's destructor is invoked, allowing for proper cleanup of resources.

Example: Virtual Destructor


#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() {
        cout << "Base destructor called" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor called" << endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj; // Output: Derived destructor called \n Base destructor called

    return 0;
}

Breakdown of the Example:

Base Class:


class Base {
public:
    virtual ~Base() {
        cout << "Base destructor called" << endl;
    }
};

The Base class has a virtual destructor.

Derived Class:


class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor called" << endl;
    }
};

The Derived class has a non-virtual destructor.

Main Function:


int main() {
    Base* obj = new Derived();
    delete obj; // Output: Derived destructor called \n Base destructor called

    return 0;
}

The delete statement ensures that both the Derived and Base destructors are called correctly due to the virtual destructor in the base class.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own and is intended to be used as a base class. It contains at least one pure virtual function, which is a function that has no implementation in the abstract class. Abstract classes are used to define a common interface for derived classes.

To declare an abstract class, include at least one pure virtual function using the syntax virtual returnType functionName() = 0;.

Example: Abstract Class


#include <iostream>
using namespace std;

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

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

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

    return 0;
}

Breakdown of the Example:

AbstractBase Class:


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

The AbstractBase class is an abstract class because it contains a pure virtual function pureVirtualFunction().

Derived Class:


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

The Derived class inherits from AbstractBase and provides an implementation for the pure virtual function, making it a concrete class.

Main Function:


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

    return 0;
}

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

Welcome to C++ Programming Tutorial