Pure Virtual Functions in CPP

Introduction

Welcome to the world of Pure Virtual Functions in C++! In this article, we’ll delve into a fundamental concept of object-oriented programming that plays a key role in designing flexible and extensible code. We’ll explore why pure virtual functions are essential, what they are, and how to use them effectively. Pure virtual functions provide a way to define a method in a base class without any implementation, allowing derived classes to implement it according to their specific requirements. Join us as we solve the significance of pure virtual functions and learn how they enable the creation of versatile and organized code structures.

What are Pure Virtual Functions?

Pure Virtual Functions:
In C++, a pure virtual function is a special type of function that is declared in a base class but doesn’t provide any implementation. It’s like a placeholder that tells the derived classes, “Hey, you need to provide your own version of this function!”

Why Do We Need Them:
Pure virtual functions are used when we want to create a base class that defines a common interface, but the exact implementation of a certain function is expected to be different in each derived class.

Syntax:
To declare a pure virtual function, we use the virtual keyword followed by the function’s prototype and = 0. Here’s an example:

class Shape {
public:
    virtual void draw() = 0;
};

Code Example:
Let’s say we have a base class Shape with a pure virtual function draw(). We’ll create two derived classes Circle and Rectangle, each providing their own implementation of the draw() function.

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Drawing a circle." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() {
        cout << "Drawing a rectangle." << endl;
    }
};

int main() {
    Circle circle;
    Rectangle rectangle;

    circle.draw();
    rectangle.draw();

    return 0;
}

Output:

Drawing a circle.
Drawing a rectangle.

Explanation:

• We define a base class Shape with a pure virtual function draw().
• Derived classes Circle and Rectangle inherit from Shape and provide their own implementations of the draw() function.
• In the main() function, we create objects of both derived classes and call the draw() function.
• Since the Shape class has a pure virtual function, it cannot be instantiated on its own. It serves as an interface for its derived classes.

Why are Pure Virtual Functions Important?

Pure virtual functions are important in C++ because they enable a powerful concept called “polymorphism.” Polymorphism allows you to write more flexible and adaptable code by letting different objects behave differently based on their specific types, even if they share a common interface.

• Common Interface: Pure virtual functions provide a way to define a common interface in a base class that multiple derived classes must adhere to. This helps in organizing your code and ensuring a consistent structure across different classes.
• Flexibility: When you use pure virtual functions, you’re telling derived classes that they must implement certain behaviors. This allows you to create a framework or blueprint for how objects of different types should behave, while still allowing each type to have its unique functionality.
• Polymorphism: Pure virtual functions are a cornerstone of polymorphism. Polymorphism allows you to write more generalized code that can work with different types of objects. When you call a pure virtual function on a base class pointer, the correct function implementation is determined at runtime based on the actual type of object the pointer is pointing to.
• Code Reusability: By defining a common interface with pure virtual functions, you’re promoting code reusability. You can create new classes that adhere to the same interface, making it easier to incorporate new functionality into your application without rewriting the same code.
• Dynamic Binding: Pure virtual functions also enable dynamic binding, where the appropriate function implementation is chosen at runtime based on the type of object. This dynamic behavior is essential for creating flexible and interactive programs.

Understand by Detailed Diagram

• Base Class: Contains a Pure Virtual Function, which is declared with = 0.
• Derived Class: Inherits from the Base Class and must provide an implementation for the Pure Virtual Function.

A Problem to Solve

Problem Statement:

You are tasked with creating a simple graphics system that can draw different shapes. You need to create a base class called ‘Shape‘, and derived classes for different shapes such as ‘Circle‘, ‘Rectangle‘, and ‘Triangle‘.

The ‘Shape‘ class should contain a pure virtual function named ‘area‘ that returns the area of the shape and another pure virtual function named ‘draw‘ that simply prints the name of the shape and its area.

Implement the derived classes for ‘Circle‘, ‘Rectangle‘, and ‘Triangle‘, providing the appropriate implementations for the ‘area‘ and ‘draw‘ functions.

Write a program that demonstrates:

1. Creation of various shape objects.
2. Storing these objects in an array of pointers to the base class Shape.
3. Iterating through this array and calling the draw method for each shape, demonstrating polymorphism.

Guide:

• You should define the ‘Shape‘ class as an abstract class by having at least one pure virtual function (e.g., virtual double area() const = 0;).
• You should define the derived classes Circle, Rectangle, and Triangle and implement the pure virtual functions from the base class in each.
• You may want to include necessary attributes in each derived class to define the shape (e.g., radius for a circle, length, and width for a rectangle, etc.).
• You can use a loop to iterate through the array of pointers to Shape, calling the draw method for each shape.

Expected Output:

The output will depend on the shapes created and their dimensions. An example output might be:

Drawing Circle with area: 78.54
Drawing Rectangle with area: 20
Drawing Triangle with area: 30

Examples of Pure Virtual Functions in C++

Let’s look at some examples to see how pure virtual functions can be used in C++. We’ll provide the code, the expected output, and a step-by-step explanation of how pure virtual functions are used.

Example 1

#include<iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() = 0; // Pure virtual function
};

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "The dog barks" << endl;
    }
};

int main() {
    Animal* animal = new Dog();

    animal->makeSound();

    delete animal;

    return 0;
}

Output:

The dog barks

Explanation:

• The code defines an abstract base class Animal with a pure virtual function makeSound().
• The Dog class inherits from Animal and overrides the makeSound() function to make a dog bark.
• A pointer of type Animal is created and assigned a dynamically allocated Dog object.
• The makeSound() function is called on the pointer, invoking the overridden function in Dog to make the dog bark.
• The dynamically allocated object is deleted to free the memory.

Example 2

#include<iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0; // Pure virtual function
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

int main() {
    Shape* shape = new Circle();

    shape->draw();

    delete shape;

    return 0;
}

Output:

Drawing a circle

Explanation:

• The code defines an abstract base class Shape with a pure virtual function ‘draw()‘.
• The ‘Circle‘ class inherits from Shape and overrides the ‘draw()‘ function to draw a circle.
• A pointer of type ‘Shape‘ is created and assigned a dynamically allocated ‘Circle‘ object.
• The ‘draw()‘ function is called on the pointer, invoking the overridden function in ‘Circle‘ to draw a circle.
• The dynamically allocated object is deleted to free the memory.

The Pros and Cons of Pure Virtual Functions

Key Takeaways

• Abstract Base Classes: Pure virtual functions make a class abstract, meaning that it cannot be instantiated on its own. It serves as a blueprint for derived classes.
• Forcing Implementation in Derived Classes: By declaring a pure virtual function in a base class, you ensure that all derived classes must provide an implementation for that function, enforcing a consistent interface.
• Enabling Polymorphism: Pure virtual functions allow for polymorphism, where a base class pointer can be used to call the appropriate derived class’s function implementation at runtime.
• Enhancing Code Structure: By using pure virtual functions, you can define a clear and consistent interface for a family of related classes, making the code more organized and maintainable.
• Facilitating Extensibility: The use of pure virtual functions makes it easier to extend the code with new derived classes without altering the existing structure, promoting a more flexible and scalable design.

Conclusion

In conclusion, pure virtual functions are like the script of a movie director in C++. By understanding how to use pure virtual functions, you can write better, more organized programs. So keep practicing, and soon you’ll be a pro at using pure virtual functions!

FAQs

1. What are pure virtual functions in C++?
   Pure virtual functions in C++ are functions in an abstract class that don’t have an implementation. They must be defined in any derived class.
2. Why do we use pure virtual functions in C++?
   We use pure virtual functions in C++ to provide a structure for other functions. They ensure that every derived class provides certain functionalities.
3. How do we use pure virtual functions in C++?
   We use pure virtual functions in C++ by declaring them in the abstract class with ‘= 0’ at the end. Derived classes must then provide the implementation for these functions.
4. Can using pure virtual functions make code more confusing?
   Yes, if you use pure virtual functions incorrectly, it can make your code more complex and harder to read. It’s important to understand when and how to use pure virtual functions effectively.
5. What are some examples of using pure virtual functions in C++?
   Some examples include using pure virtual functions to make different types of animal objects make different sounds, or to draw different types of shape objects differently.