Abstract Classes and Pure Virtual Functions in C++
In the C++ programming language, abstract classes and pure virtual functions are built-in class features and functions that are essential concepts for creating abstract classes and pure virtual interfaces to existing classes and providing polymorphic class behavior properties in OOPS object-oriented programming. Abstract classes and pure virtual functions are used to declare or define base or root classes that cannot be directly instantiated within a class. However, C++ users can inherit them from derived class subclasses that implement a specific abstract class and pure virtual function functionality within an existing class.
What is an abstract class in C++ programming?
In C++ programming, an abstract class is a user-defined custom class that has at least one pure virtual function created or defined, and this pure virtual function cannot be automatically instantiated within an existing class. It acts as a base class for other classes to derive from, and provides a common interface for derived classes within the base class.
An abstract class creates or defines a structure within the base class, but leaves some class methods undefined, forcing derived classes or subclasses to provide their own specialized class implementations for those class methods.
An abstract class is used to declare a common class interface or contract within the base class, which derived classes or subclasses defined in the base class must follow, ensuring consistency across multiple individual class implementations within the existing class.
What is a pure virtual function in C++ programming?
A pure virtual function in C++ programming is a custom, user-declared virtual function defined within a class. A pure virtual function must be implemented by a derived class or subclass defined in the base class. The syntax for declaring a pure virtual function in a C++ program is to set the class function declaration to 0.
virtual void func() = 0;
This means that the existing user-defined function has no body defined in the base or root class, and must be overridden in any derived class or subclass that is not abstract in nature.
Syntax of an abstract class in C++.
class AbstractClass {
public:
virtual void testFunction() = 0; // Here a pure virtual function is defined with the value 0
virtual ~AbstractClass() {} // Here we have defined a destructor, which can be a virtual function
};
Explanation of an abstract class in C++.
- Here, the function declaration in the abstract class is initialized with = 0, which creates this function as a pure virtual function.
- This makes the existing class abstract, as it defines at least one pure virtual function.
Unique features and functions of abstract classes and pure virtual functions in C++.
- Remember that abstract classes cannot be directly instantiated in C++ programming.
- A user-defined pure virtual function in C++ programming defines a common class interface but leaves its implementation completely to the derived or subclass class.
- To create a concrete class (i.e., user-defined classes that can be instantiated within the class), the derived class or subclass must override all pure virtual functions.
- Here, a user-defined abstract class can still define concrete functions (e.g., functions that provide implementations), but you are not required to do so.
- A pure virtual function in a user-defined class allows C++ users to define a contract that dictates that derived or subclassed classes directly implement certain class functionality.
Abstract Class and Pure Virtual Function Concepts in C++.
So, let’s create an example in C++ programming, where we define an abstract class Diagram with a pure virtual function, which is implemented by a derived class.
Example of an abstract class and a pure virtual function in C++.
#include <iostream>
#include <cmath>
using namespace std;
class Diagram {
public:
virtual double area() = 0; // Here we create an area pure virtual function initialized with a value of 0
virtual double perimeter() = 0; // Here we create a perimeter pure virtual function initialized with a value of 0
virtual ~Diagram() {} // Here we create a base class virtual destructor
};
class Circle : public Diagram {
private:
double radius;
Public:
Circle(double r) : radius(r) {}
double area() override {
return M_PI * radius * radius;
}
double perimeter() override {
return 2 * M_PI * radius;
}
};
class Triangle : public Diagram {
private:
double p, q, r;
Public:
Triangle(double s1, double s2, double s3) : p(s1), q(s2), r(s3) {}
double area() override {
double s = (p + q + r) / 2; // here we use Semi-perimeter
return sqrt(s * (s – p) * (s – q) * (s – r)); //here we apply Heron’s formula
}
double perimeter() override {
return p + q + r;
}
};
int main() {
Diagram* Diagram1 = new Circle(7.0); // here we define Circle with radius 7 value
Diagram* Diagram2 = new Triangle(4.0, 6.0, 7.0); // here we define Triangle with 3 sides 4, 6, 7
cout << “The area of circle is – ” << Diagram1->area() << endl;
cout << “The Perimeter of circle is – ” << Diagram1->perimeter() << endl;
cout << “The area of Triangle is – ” << Diagram2->area() << endl;
cout << “The Perimeter of Triangle is – ” << Diagram2->perimeter() << endl;
deleteDiagram1;
deleteDiagram2;
return 0;
}
Explaining the Concepts of an Abstract Class and Pure Virtual Function in C++.
- In this example, Diagram, a custom user-defined class, is an abstract class because it creates two custom pure virtual functions, the area() and perimeter() functions. These functions define a contract for all Diagram classes, but the Diagram class itself has no implementation.
- The Circle and Triangle classes inherit from Diagram and provide their own implementations of area() and perimeter().
- The program uses base class pointers (Diagram*) to create objects of type Circle and Triangle, representing the concept of polymorphism.
- We can call the area() and perimeter() functions on these class objects, and these functions are invoked in the appropriate derived subclass.
