Introduction to Abstract Class in C++
A class is a data type defined by the user, and it has its own data members and functions. The members and functions can be used by creating an object or instance of that class. Memory is allocated for a class only when an object is created. When we want to derive some behaviors or characteristics from one class to another class, we use the concept of inheritance. This is the method of inheriting few properties from parent class (base class) to child class (derived 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. An abstract class is a class with 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. 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 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.
4.5 (1,895 ratings)
View Course
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 abstract class. Instead, 2nd and 3rd 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 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. Pure virtual destructor is a destructor that is assigned to 0 but it must be defined by the same class, as destructor is not usually overridden.
Example of Constructor and Destructor for Abstract Class in C++
Here, we discuss 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 hence preventing the derived class from becoming an abstract class. The pure virtual destructor is defined by the Base class outside the class. 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 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 abstract class, but 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 as well as the implementation of constructor and destructor in C++ along with its example. You may also look at the following articles to learn more-
