Abstract Class in C++

Introduction to Abstract Class in C++

An abstract class is a class that is declared with an abstract keyword which is a restricted class hence cannot be used to create objects; however, they can be subclassed. To access abstract class, it must be inherited from another class. In class implementation and inheritance, when we want to define the same functions both in the base and derived class, we use the keyword ‘virtual’ along with the base class function. This ‘virtual’ function specifies that the same function is redefined or overridden in the derived class. Therefore, an abstract class is a class with a pure virtual function.

Now, what is a pure virtual function? A pure virtual function is a virtual function that has no body and is assigned as 0. This type of function is implemented when we need a function, but we do not currently know what its function is. Therefore, this function needs to be implemented or defined in the derived class. If not, then the derived class also becomes an abstract class.

A pure virtual function is defined as follow:

virtual void func() = 0;

Examples of Abstract Class in C++

Here, we discuss the different Examples of Abstract Class in C++ with details:

Example #1

Code:

#include<iostream>
using namespace std;
class Sample_Class {
int a = 5;
public:
virtual void sample_func() = 0;
void print_func() {
cout << a;
}
};
class Derived_Class : public Sample_Class {
public:
void sample_func() {
cout << "pure virtual function is implemented";
}
};
int main() {
Derived_Class d_object;
d_object.sample_func();
}

Output:

Code Explanation: Here, Sample_Class is the base class, and Derived_Class is derived from the Sample_Class. A pure virtual function called sample_func() is declared in the base class. It is assigned to 0, which means it has nobody, and nothing is implemented inside the function. Thus, the base class has become an abstract class as it has a pure virtual function. Initially, when the Derived_Class is derived from the base class, it also becomes an abstract class. But in the derived class, the sample_func() class is defined, which prevents the derived class from becoming an abstract class. When the derived class object is created, and the function is called, we will get the output printed as ‘pure virtual function is implemented’.

An abstract class cannot be instantiated, which means that we cannot create an instance or object for an abstract class. The object cannot be created because the class is not implemented fully. It is actually a base for a class that is implemented fully later on. But pointers or references can be created for an abstract class. This pointer can be used to call the derived class functions. An abstract class can have other data members and functions similar to normal class implementation along with a pure virtual function.

The above point can be explained through the below program.

Example #2

Code:

class Class1 {
int a;
public:
virtual void func1() = 0;
void func2() {
cout << "base class";
}
};
class Class2 : public Class1 {
public:
void func1() {
cout << "func1 in derived class";
}
};
int main() {
Class1 b;   //---------- > this line will cause an error
//Class1 *b = new Class2(); //---------- > pointer can be created, so this line is correct
// b -> func1();
}

Output:

Here we will get an error as an object cannot be created for the abstract class. Instead, the 2^nd and 3^rd line of code can be implemented, a pointer can be created and can be used to call derived class function.

Code Explanation: Here, in the above function, Class1 is the base class, and as it has a pure virtual function (func1), it has become an abstract class. Class2 is derived from the parent class Class1. The func1 is defined in the derived class. In the main function, when we try to create an object of type base class, we will get an error, as objects cannot be created for abstract class. Whereas when we try to create a pointer of base class type, it will be created successfully, and we can point it to the derived class. This pointer can be used to call the derived class function.

An abstract class can have a constructor similar to normal class implementation. In the case of the destructor, we can declare a pure virtual destructor. It is important to have a destructor to delete the memory allocated for the class. A pure virtual destructor is a destructor that is assigned to 0, but it must be defined by the same class, as the destructor is not usually overridden.

Example of Constructor and Destructor for Abstract Class in C++

Here, we discuss the Example of Constructor and Destructor for Abstract Class in C++ with details.

Code:

class Base {
public:
int a;
virtual void func1() = 0;
// Constructor
Base(int i) {
a = i;
}
// Pure Virtual destructor
virtual ~Base() = 0;
};
// Pure virtual destructor is defined
Base :: ~Base() {
cout << "Pure virtual destructor is defined here" << endl;
}
class Derived : public Base {
int b;
public:
// Constructor of derived class
Derived(int x, int y) : Base(y) { b = x; }
// Destructor of derived class
~Derived() {
cout << "Derived class destructor" << endl;
}
//Definition for pure virtual function
void func1() {
cout << "The value of a is " << a << " and b is " << b << endl;
}
};
int main() {
Base *b = new Derived(5,10);
b->func1();
delete b;
}

Output:

Code Explanation: Here, in the above example Base class is an abstract class with pure virtual function func1(), a constructor and a pure virtual destructor. The pure virtual function is defined in the derived class, preventing the derived class from becoming an abstract class. The Base class outside the class defines the pure virtual destructor. If we want to define the member function of a class outside the class, the scope resolution operator should be used, as shown in the example. A pointer of base class type is created and pointed to the derived class. When the destructor is called using ‘delete’, first the derived class destructor is called, and then the base class destructor is called.

Conclusion

Hence, to compile everything about an abstract class, we can say that the abstract class is a class with a pure virtual function. This pure virtual function must be defined in the derived class; if not, then the derived class also becomes an abstract class. The object cannot be created for the abstract class, but a pointer can be created, which can be pointed to the derived class.

Recommended Articles

This is a guide to Abstract Class in C++. Here we discuss the introduction to abstract class and the implementation of constructor and destructor in C++ and its example. You may also look at the following articles to learn more-

1. Abstract Class in Python
2. Abstract Class in Java
3. Constructor and Destructor in C++
4. Overriding in C++