Abstract Classes in C++

Introduction

When you are writing Object Oriented Code, one of your main objectives is to structure code so that it is easy to relate to real life. There are two important concepts you need to be familiar with. They are Inheritance and Abstraction.

Let’s look at these, one by one.

Inheritance

You must have seen some families where all the members of the same family have the same eye color. Ever wondered why? Well, it is because of inheritance. It is a biological concept that tells us that children get (inherit) some of the features (like eye color and hairstyle) from their parents.

But what does this has to do with this article? Well, in Object-Oriented Programming, we use this concept extensively. We create Base Class(parent class) and Derived Class(Child class). Here also, the derived class inherits its base class's features (in this case, they are methods and properties). Learn more about Inheritance in C++, here.

Abstraction

Let’s say you are driving a car. When you increase the speed, do you ever think about what is happening inside the engine? Or, when you shift gears, do you know how the gearbox works? A better question would be do you even need to know?

The same goes for many things we do daily. When we switch on the TV, we press a button from the remote trusting the remote to do its job, and we don’t care how it does what it does.

This is called abstraction.

Abstraction removes the implementation details and gives users a simple way to interact with things.

Another example would be when you go to Google. You are presented with a simple box to type your query and a cute little search icon. You don’t need to worry about how Google gives you all the results.

Another way to frame this would be, with the help of abstraction, for a programmer hides all the implementation details that the user does not need to see.

Abstract Class in C++

An abstract class is a class that contains at least one pure virtual function, and these classes cannot be instantiated.

Abstract Classes came from the idea of abstraction. Before we dive into technicalities, let’s first consider a scenario where you might use this concept.

Abstract Class Example

Let’s say we are making a calculator which returns the perimeter of the shape we put in. Think of what kind of code you would write for such a calculator. You might start with some initial shapes and hardcode the perimeter by making separate functions inside the Shape class.

The class might look something like this –

class Shape {
  public:
    // All the functions of both square and rectangle are clubbed together in a single class.
    void width(int w) {
        shape_width = w;
    }
    void height(int h) {
      shape_height = h;
    }
    int perimeterOfSquare(int s) {
      return 4 * s;
    }
    int perimeterOfRectange(int l, int b) {
      return 2 * (l + b);
    }
    
  protected:
    int shape_width;
    int shape_height;
};

This will work, but OOP suggests that we should try to stay close to real-world logic. So, we can make a class Shape as a parent class and then make separate classes like Square and Rectangle as child classes. This will make the code easier to maintain, and if you plan to add anything new in the future, then you can add that in the child class. To implement this feature, we need to use Abstract Classes. Abstract classes in C++ need at least one pure virtual function in a class. The classes that inherit the abstract class must define the pure virtual function; otherwise, the subclass will become an abstract class.

Restrictions on Abstract Classes

There are some restrictions on abstract classes in C++.

Abstract classes cannot be used for the following –

• Variables or member data
• Argument types
• Function return types
• Types of explicit conversions.

The constructors of the abstract class can call other member functions, but if they directly or indirectly call a pure virtual function, then the result is undefined.

But wait! What is a pure virtual function anyway?

To understand the pure virtual function, first, let’s understand virtual functions.

A virtual function in C++ is a member function declared within a base class and redefined by the derived class.

A pure virtual function (or abstract function) is a virtual function with no definition/logic. It is declared by assigning 0 at the time of declaration.

Let’s take a look at an example that will make things clear.

#include<iostream>
using namespace std;

// Shape class.
class Shape {
  public:
    
    // Function to calculate the parameter, declared as pure virtual, so all the derived classes necessarily need to implement this.
    virtual int perimeter() = 0;
    void width(int w) {
      shape_width = w;
    }
    void height(int h) {
      shape_height = h;
    }
  
  protected:
    int shape_width;
    int shape_height;
};

class Rectangle: public Shape {
  public: 
    // Class Rectangle provided implementation of perimeter() function.
    int perimeter() {
      return (2 * (shape_width + shape_height));
    }
};

class Square: public Shape {
  public: 
    // Class Square provided implementation of perimeter() function.
    int perimeter() {
      return (4 * shape_width);
    }
};

int main() {
  Rectangle R;
  Square S;

  R.width(10);
  R.height(5);
  S.width(10);

  cout << "Perimeter of Rectangle: " << R.perimeter() << endl;
  cout << "Perimeter of Square: " << S.perimeter() << endl;
  return 0;
}

Output –

Perimeter of Rectangle : 30
Perimeter of Square: 40

In the above code, you can see that the function perimeter() is a pure virtual function, the “virtual” keyword is used, and it is assigned a value of 0.

In the derived classes, Rectangle and Shape redefine the pure virtual function.

Characteristics of Abstract Class in C++

1. Abstract Classes must have at least one pure virtual function.

virtual int perimeter() = 0;

2. Abstract Classes cannot be instantiated, but pointers and references of Abstract Class types can be created. You cannot create an object of an abstract class. Here is an example of a pointer to an abstract class.

#include<iostream>
using namespace std;

class Base {
  public:
    virtual void print() = 0;
};

class Derived: public Base {
  public: 
    void print() {
      cout << "This is from the derived class \n";
    }
};

int main(void) {
  Base* basePointer = new Derived();
  basePointer -> print();
  return 0;
}

Output –

This is from the derived class

3. Abstract Classes are mainly used for Upcasting, which means its derived classes can use its interface.
4. Classes that inherit the Abstract Class must implement all pure virtual functions. If they do not, those classes will also be treated as abstract classes.

Why Can’t We Make an Abstract Class Object?

Abstract classes in C++ cannot be instantiated because they are “abstract”. It’s like someone is telling you to draw an animal without telling you which specific animal. You can only draw if the person asks you to draw a cat, dog, etc., but an animal is abstract.

The same is the case with abstract classes in C++, so we can’t create objects, but we can create a pointer of an abstract class.