What is a pure virtual function in C++?
Table of Contents
- Introduction
- Understanding Pure Virtual Functions
- Why Use Pure Virtual Functions?
- Practical Examples
- Conclusion
Introduction
A pure virtual function in C++ is a type of virtual function that must be overridden by any derived class. Declaring a function as pure virtual in a class makes that class abstract, meaning it cannot be instantiated on its own. Pure virtual functions play a critical role in enforcing certain behaviors in derived classes and are fundamental in designing interfaces and achieving polymorphism in object-oriented programming.
Understanding Pure Virtual Functions
What is a Pure Virtual Function?
A pure virtual function in C++ is a virtual function that is declared by assigning 0 to it in its declaration within a class. This signals that the function does not have a definition in the base class and must be overridden in any derived class.
Syntax Example:
In this example, display() is a pure virtual function. The = 0 syntax indicates that the function is pure virtual and must be implemented by any non-abstract derived class.
Role of Pure Virtual Functions in Abstract Classes
When a class contains one or more pure virtual functions, it is considered an abstract class. An abstract class cannot be instantiated, meaning you cannot create objects of that class directly. Instead, the class serves as a blueprint for other classes, which must provide implementations for the pure virtual functions.
Example:
In this example, Animal is an abstract class because it contains a pure virtual function sound(). The derived classes Dog and Cat must provide their implementations of sound().
Why Use Pure Virtual Functions?
Enforcing Implementation in Derived Classes
Pure virtual functions are used to enforce that certain functions must be implemented by all derived classes. This ensures that derived classes adhere to a specific interface or contract defined by the base class.
Example:
In this example, the Shape class defines a pure virtual function area(). Any class derived from Shape must implement the area() function.
Enabling Polymorphism
Pure virtual functions are essential for achieving polymorphism in C++. They allow the base class to define a common interface, while the derived classes provide specific implementations. This enables the use of base class pointers or references to call the derived class functions.
Example:
Here, the printArea function accepts a reference to a Shape object. Thanks to polymorphism, the correct area() function is called based on the actual type of the object passed (either Circle or Rectangle).
Practical Examples
Example 1: Interface Design with Pure Virtual Functions
Consider designing a simple interface for different types of payments, where each payment method must implement a processPayment() function.
Example:
In this example, the Payment class is an abstract class that defines the processPayment() pure virtual function. The derived classes CreditCardPayment and PayPalPayment provide specific implementations of this function.
Example 2: Abstract Base Class for Different Vehicles
Another practical example is creating an abstract base class for different types of vehicles, where each vehicle must implement a startEngine() function.
Example:
Here, the Vehicle class serves as an abstract base class with the pure virtual function startEngine(). Each derived class (Car and Motorcycle) must implement this function.
Conclusion
Pure virtual functions in C++ are a powerful tool for enforcing derived class implementation and enabling polymorphism. They are central to designing abstract classes and interfaces, ensuring that specific behaviors are implemented by all derived classes. Understanding and utilizing pure virtual functions effectively allows for the creation of flexible and maintainable object-oriented designs in C++.