C++ - Polymorphism

Polymorphism in C++

Introduction

Polymorphism is one of the core concepts of Object-Oriented Programming (OOP) in C++. It allows one function or method to behave differently based on the context. The word "polymorphism" comes from Greek, meaning "many forms." In C++, polymorphism allows you to use a single interface to represent different types of objects.

There are two types of polymorphism in C++:

• Compile-time polymorphism (also known as static polymorphism)
• Runtime polymorphism (also known as dynamic polymorphism)

Types of Polymorphism in C++

1. Compile-time Polymorphism (Static Polymorphism)

Compile-time polymorphism is resolved during the compilation process. It allows you to perform method overloading and operator overloading. This type of polymorphism is achieved by function overloading or operator overloading.

Function Overloading

Function overloading is when multiple functions have the same name but different parameters (number or type of parameters). The appropriate function is called based on the function signature.

class Example {
public:
    void display(int i) {
        cout << "Integer: " << i << endl;
    }
    void display(double d) {
        cout << "Double: " << d << endl;
    }
};

int main() {
    Example obj;
    obj.display(5);       // Calls display(int)
    obj.display(5.5);     // Calls display(double)
    return 0;
}
    

In this example, we have two functions with the same name display() but with different parameters. The compiler chooses the appropriate function based on the argument type.

Operator Overloading

Operator overloading allows you to redefine the meaning of operators for user-defined classes. For example, you can overload the + operator to add two objects of a custom class.

class Complex {
private:
    int real, imag;
public:
    Complex(int r, int i) : real(r), imag(i) {}
    Complex operator + (const Complex& obj) {
        return Complex(real + obj.real, imag + obj.imag);
    }
    void display() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex num1(3, 4), num2(1, 2);
    Complex result = num1 + num2;  // Using overloaded + operator
    result.display();
    return 0;
}
    

In this example, the + operator is overloaded to add two Complex numbers. The operator is now defined for user-defined types, allowing objects of the class to use the + operator.

2. Runtime Polymorphism (Dynamic Polymorphism)

Runtime polymorphism is achieved through inheritance and virtual functions. It occurs at runtime, and the function that gets called is determined dynamically. The key to runtime polymorphism in C++ is the use of virtual functions and base class pointers or references to derived class objects.

Virtual Functions

A virtual function is a member function in the base class that you expect to be overridden in derived classes. By declaring a function as virtual in the base class, you ensure that the correct function is called for an object, regardless of the type of reference (base or derived) used for the function call.

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound" << endl;
    }
};

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

class Cat : public Animal {
public:
    void sound() override {
        cout << "Cat meows" << endl;
    }
};

int main() {
    Animal* animal;
    Dog dog;
    Cat cat;
    
    animal = &dog;
    animal->sound();  // Calls Dog's sound()

    animal = &cat;
    animal->sound();  // Calls Cat's sound()

    return 0;
}
    

In this example, sound() is a virtual function in the base class Animal. When a base class pointer (animal) points to a derived class object (dog or cat), the appropriate overridden version of sound() is called based on the actual object type, not the pointer type.

Virtual Destructor

A virtual destructor is necessary when a class is intended to be used as a base class for other classes. It ensures that the destructors of derived classes are called properly when an object is deleted through a base class pointer.

class Base {
public:
    virtual ~Base() {
        cout << "Base Destructor" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived Destructor" << endl;
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr;  // Calls Derived destructor, then Base destructor
    return 0;
}
    

Here, the destructor of the derived class Derived is called first, and then the base class Base destructor is called, thanks to the virtual destructor.

Advantages of Polymorphism

• Code Reusability: Polymorphism allows you to write more generic and reusable code, as the same interface can be used for different types of objects.
• Flexibility: The same function or operator can work with objects of different types, which increases flexibility and reduces the complexity of code.
• Maintainability: It makes code easier to maintain and extend. New classes can be added without modifying the existing code, provided the new classes follow the expected interface.

Summary

Polymorphism is a powerful feature in C++ that enables flexibility and reusability. By using both compile-time and runtime polymorphism, you can create programs that are easy to extend and maintain, while keeping the codebase clean and efficient. Understanding how to apply polymorphism in different contexts is essential for mastering object-oriented programming in C++.