Abstract Classes in C++

Introduction

Abstract classes in C++ are a fundamental concept in object-oriented programming (OOP). An abstract class is a class that cannot be instantiated, meaning you cannot create objects of an abstract class. Instead, it is meant to be inherited by other classes. Abstract classes serve as a blueprint for other classes, enforcing certain methods to be implemented by derived classes.

Defining an Abstract Class

An abstract class in C++ is defined by including at least one pure virtual function. A pure virtual function is declared by assigning 0 in its declaration. Here's the syntax:

class AbstractClass {
public:
    virtual void pureVirtualFunction() = 0;
};
                

In the example above, pureVirtualFunction is a pure virtual function, making AbstractClass an abstract class.

Implementing Abstract Classes

Derived classes must provide an implementation for all pure virtual functions of the abstract class. If they fail to do so, they also become abstract classes. Here's an example:

#include <iostream>

class AbstractClass {
public:
    virtual void pureVirtualFunction() = 0;
};

class ConcreteClass : public AbstractClass {
public:
    void pureVirtualFunction() override {
        std::cout << "Implementation of pure virtual function." << std::endl;
    }
};

int main() {
    ConcreteClass obj;
    obj.pureVirtualFunction();
    return 0;
}
                

In this example, ConcreteClass provides an implementation for the pure virtual function pureVirtualFunction. Therefore, ConcreteClass is not an abstract class and can be instantiated.

Why Use Abstract Classes?

Abstract classes are used to define an interface without providing a full implementation. This allows you to create a common base class that enforces a contract for derived classes. Some benefits include:

• Enforcing a common interface for derived classes.
• Promoting code reusability and modularity.
• Facilitating polymorphism by allowing you to treat different derived classes uniformly.

Real-world Example

Consider a scenario where you have different types of shapes, and you want to calculate their areas. You can use an abstract class to define a common interface for all shapes:

#include <iostream>

class Shape {
public:
    virtual double area() = 0; // Pure virtual function
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() override {
        return width * height;
    }
};

int main() {
    Shape* shape1 = new Circle(5.0);
    Shape* shape2 = new Rectangle(4.0, 6.0);

    std::cout << "Circle area: " << shape1->area() << std::endl;
    std::cout << "Rectangle area: " << shape2->area() << std::endl;

    delete shape1;
    delete shape2;

    return 0;
}
                

In this example, the Shape class is an abstract class with a pure virtual function area. The Circle and Rectangle classes provide their own implementations of the area function. This allows you to use the Shape pointer to call the area function polymorphically.

Conclusion

Abstract classes in C++ are a powerful feature that allows you to define a common interface for related classes. By using pure virtual functions, you can enforce derived classes to provide specific implementations, promoting code reusability and modularity. Understanding and using abstract classes effectively will help you create more robust and maintainable object-oriented programs.