Polymorphism in C++: A Complete Guide

Object-oriented programming (OOP) offers powerful ways to make our code more adaptable and reusable. Polymorphism is a key concept in OOP that allows us to write code that gracefully handles objects of different types.

The word itself, derived from Greek, means "many forms." In essence, polymorphism lets objects or functions take on multiple behaviors, enhancing code flexibility and adaptability. Think of it as the ability to give a single instruction ("draw yourself") to a variety of shapes, and each shape knows how to respond correctly.

In this tutorial, I will delve into the foundations of polymorphism in C++. With the help of this guide and some examples, I will help you write cleaner, more flexible, and easier-to-maintain code.

Understanding Polymorphism

Imagine a scenario where you have a variety of shapes: circles, squares, and triangles. Polymorphism would allow you to define a general function called calculateArea(). You could then use this single function to find the area of any shape, regardless of its specific type.

The beauty of polymorphism is that the code doesn't need to know the exact shape it's dealing with at the time it's written. This makes your programs more versatile and easier to maintain.

Types of Polymorphism in C++

There are two primary types of polymorphism in C plus plus:

1. Compile-time polymorphism in C++ (Static polymorphism): Here, the decision of which function to call happens during the compilation stage. C++ achieves this primarily through:

• Function overloading: Multiple functions share the same name but differ in their parameter lists (number of parameters or their types).
• Operator overloading: You can redefine how built-in C++ operators (+, -, etc.) behave when used with custom-made objects.

2. Runtime polymorphism in C++ (Dynamic polymorphism): In this case, the decision about which function to call is made while the program is running (at runtime). C++ implements runtime polymorphism mainly using:

• Virtual functions and inheritance: You declare a function as 'virtual' in a base class, and then override (redefine) it in derived classes. Pointers and references to the base class can then call the correct overridden version of the function based on the actual type of object they point to.

Compile-Time Polymorphism in C++ Examples

Function Overloading

Code:

#include <iostream> // Header for input/output functions (cin, cout, endl)
using namespace std; // Avoids repeatedly using std:: before standard library elements
void print(int num) { // Function definition with integer parameter
cout << "Integer: " << num << endl;
}
void print(double decimal) { // Function definition with double parameter
cout << "Double: " << decimal << endl;
}
int main() { // Main function, program execution starts here
print(5); // Calls print(int) with integer argument (5)
print(3.14); // Calls print(double) with double argument (3.14)
return 0; // Indicates successful program termination
}

This example presents function overloading. We have two functions called print, each taking a different parameter type (one for integers, one for doubles). At compile time, C++ automatically determines which print function to call based on the type of argument you pass.

Operator Overloading

Code:

#include <iostream>
using namespace std;
class Complex { // Class definition for complex numbers
public:
double real;
double imag;
Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {} // Constructor with default arguments
Complex operator+(const Complex &other) { // Overloaded + operator
return Complex(real + other.real, imag + other.imag);
}
};
int main() {
Complex c1(2, 3); // Creates a Complex object with real = 2, imag = 3
Complex c2(1, 4); // Creates another Complex object
Complex result = c1 + c2; // Uses the overloaded + operator
cout << "Result: " << result.real << " + " << result.imag << "i" << endl;
return 0;
}

Operator overloading lets us redefine how built-in operators work with our custom classes. Here, + is overloaded for Complex objects. This means we can add Complex numbers with natural syntax (e.g., c1 + c2).

Runtime Polymorphism in C++ Example

Code:

#include <iostream>
#include <cmath> // For mathematical functions like PI
using namespace std;
class Shape {
public:
virtual double calculateArea() = 0;
};
class Circle : public Shape {
private: // Consider making radius a private member
double radius;
public:
Circle(double r) : radius(r) {} // Constructor to set circle's radius
double calculateArea() override {
return M_PI * radius * radius; // M_PI is a constant representing pi
}
};
class Rectangle : public Shape {
private: // Consider making these private members
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {} // Constructor
double calculateArea() override {
return width * height;
}
};
int main() {
Shape *shape; // Declare a base class pointer
Circle circle(5); // Create a circle object
shape = &circle;
cout << "Area of circle: " << shape->calculateArea() << endl;
Rectangle rectangle(3, 4); // Create a rectangle object
shape = &rectangle;
cout << "Area of rectangle: " << shape->calculateArea() << endl;
return 0;
}

In the above code, I have included <cmath> for mathematical constants like M_PI. The Shape class defines a pure virtual function calculateArea(), making it an abstract base class that outlines the behavior for derived shapes.

Both Circle and Rectangle inherit from Shape and override calculateArea(), providing specific implementations for calculating the area of their respective shapes. In main, a Shape pointer is used. It can point to either a Circle or a Rectangle object, demonstrating polymorphism. Calling calculateArea() through this pointer dynamically selects the correct implementation at runtime.

Advanced Polymorphism in C++ Examples

Templates and Polymorphism

Templates provide a way to create generic functions and classes that work with various data types, enabling compile-time polymorphism. Here's an example combining templates and inheritance:

Code:

#include <iostream>
using namespace std;
template <typename T>
class Shape {
public:
virtual void draw() = 0;
};
template <typename T>
class Circle : public Shape<T> {
public:
void draw() override {
cout << "Drawing a Circle" << endl;
}
};
template <typename T>
class Rectangle : public Shape<T> {
public:
void draw() override {
cout << "Drawing a Rectangle" << endl;
}
};
int main() {
Shape<int>* shape1 = new Circle<int>();
Shape<double>* shape2 = new Rectangle<double>();
shape1->draw(); // Outputs: Drawing a Circle
shape2->draw(); // Outputs: Drawing a Rectangle
delete shape1;
delete shape2;
return 0;
}

In this code, we define templated Shape, Circle, and Rectangle classes. The Shape class acts as an abstract base class with a pure virtual draw() function. In main, we create pointers of type Shape<int> and Shape<double>, demonstrating that the templates can work with different data types. Polymorphism works similarly, the draw() functions are dispatched dynamically based on the actual object type.

CRTP for Interface-like Behavior

CRTP (Curiously Recurring Template Pattern) is a technique that allows compile-time polymorphism while achieving a form of static inheritance. Let's see an example:

Code:

#include <iostream>
#include <string>
template <typename Derived>
class Printable {
public:
void print() {
static_cast<Derived*>(this)->printDetails();
}
};
class Person : public Printable<Person> {
private:
std::string name;
int age;
public:
Person(const std::string& n, int a) : name(n), age(a) {}
void printDetails() {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};
class Product : public Printable<Product> {
private:
std::string description;
double price;
public:
Product(const std::string& desc, double p) : description(desc), price(p) {}
void printDetails() {
std::cout << "Description: " << description << ", Price: $" << price << std::endl;
}
};
int main() {
Person john("John Doe", 35);
Product book("The C++ Guide", 24.99);
john.print(); // Output: Name: John Doe, Age: 35
book.print(); // Output: Description: The C++ Guide, Price: $24.99
return 0;
}

In this code, the Printable class acts like an interface using the CRTP technique, forcing derived classes to implement printDetails(). Person and Product can implement their unique printing behavior and the print() function in Printable provides a uniform way to print any derived type.

Multiple Inheritance and Virtual Functions

Code:

#include <iostream>
using namespace std;
class Shape {
public:
virtual void draw() {
cout << "Generic Shape" << endl;
}
};
class Colored {
public:
virtual void showColor() {
cout << "Generic Color" << endl;
}
};
class ColoredCircle : public Shape, public Colored {
public:
void draw() override {
cout << "Drawing a Colored Circle" << endl;
}
void showColor() override {
cout << "Color of the Circle" << endl;
}
};
int main() {
ColoredCircle coloredCircle;
coloredCircle.draw(); // Outputs: Drawing a Colored Circle
coloredCircle.showColor(); // Outputs: Color of the Circle
return 0;
}

In the above code, Shape and Colored are base classes with virtual functions. ColoredCircle inherits from both Shape and Colored, getting the capabilities of both. ColoredCircle overrides both draw() and showColor(), providing specialized behavior.

If both base classes were to have functions with the same name and signature without being virtual, ColoredCircle would face ambiguity. Using virtual is essential in multiple inheritance scenarios.

If you wish to master C++, you can enroll in one of upGrad’s software engineering courses.

Advantages of Polymorphism in C++

Here are the key advantages of polymorphism in C++:

• Code reusability: Polymorphism lets you write more generic code that works with various object types.
• Extensibility: New classes with different behaviors can be easily added without modifying existing code.
• Maintainability: Polymorphic code tends to be better organized and easier to understand.

Wrapping Up

According to me, polymorphism is a potent tool in the C++ programmer's arsenal. By understanding compile-time and runtime polymorphism, I believe that you'll write more flexible, adaptable, and elegant object-oriented code.

If you wish to become a master of C++ and concepts such as as polymorphism in C++, you can enrol yourself in one of upGrad’s software engineering programs.

Frequently Asked Questions

1. What is a polymorphism in C++?

Polymorphism in C++ is the ability of objects of different types to respond differently to the same method or function call. This is primarily achieved through inheritance, virtual functions, and function overloading.

2. What is polymorphism and its example?

Polymorphism means "many forms." An example would be a Shape base class with derived classes like Circle, Triangle, and Rectangle. All shapes could have a calculateArea() method, but each subclass implements the calculation uniquely.

3. What is polymorphism in C programming?

C doesn't directly support object-oriented polymorphism. However, you can achieve a limited form of polymorphism using function pointers and carefully designed function signatures.

4. What is polymorphism in compiler design?

In compiler design, polymorphism often arises in the context of type systems and name resolution. A compiler needs to polymorphically determine the correct type and meaning of an operator or function call based on the types of the arguments involved.

5. Where is polymorphism used in C++?

Polymorphism in C++ is used widely to:

• Abstract interfaces: Create flexible designs.
• Game development: Different entities behaving uniquely.
• GUI systems: Handling various widgets with a common interface.

6. What is polymorphism data in OOP?

There's no specific term called "polymorphism data" in OOP. Polymorphism is primarily about how functions or methods behave differently based on the object's type, not the data itself.