Polymorphism in C++

What You’ll Learn 📚

• Understand the core concept of polymorphism
• Learn key terminology
• Explore simple and complex examples
• Common questions and answers
• Troubleshooting tips

Introduction to Polymorphism

Polymorphism in C++ allows us to perform a single action in different ways. It’s one of the cornerstones of object-oriented programming, enabling flexibility and integration in your code. The term ‘polymorphism’ comes from the Greek words ‘poly’ (many) and ‘morph’ (form), meaning something that takes many forms. In C++, polymorphism is mainly achieved through virtual functions.

Key Terminology

• Polymorphism: The ability of different objects to be accessed through the same interface.
• Virtual Function: A function in a base class that can be overridden in a derived class.
• Base Class: The class from which other classes derive.
• Derived Class: A class that inherits from a base class.

Simple Example: Understanding the Basics

#include <iostream>using namespace std;class Animal {public:    virtual void speak() {        cout << "Animal speaks" << endl;    }};class Dog : public Animal {public:    void speak() override {        cout << "Woof!" << endl;    }};int main() {    Animal* animalPtr;    Dog dog;    animalPtr = &dog;    animalPtr->speak(); // Outputs: Woof!    return 0;}

Progressively Complex Examples

Example 1: Multiple Derived Classes

#include <iostream>using namespace std;class Animal {public:    virtual void speak() {        cout << "Animal speaks" << endl;    }};class Dog : public Animal {public:    void speak() override {        cout << "Woof!" << endl;    }};class Cat : public Animal {public:    void speak() override {        cout << "Meow!" << endl;    }};int main() {    Animal* animalPtr;    Dog dog;    Cat cat;    animalPtr = &dog;    animalPtr->speak(); // Outputs: Woof!    animalPtr = &cat;    animalPtr->speak(); // Outputs: Meow!    return 0;}

Example 2: Polymorphic Arrays

#include <iostream>using namespace std;class Animal {public:    virtual void speak() {        cout << "Animal speaks" << endl;    }};class Dog : public Animal {public:    void speak() override {        cout << "Woof!" << endl;    }};class Cat : public Animal {public:    void speak() override {        cout << "Meow!" << endl;    }};int main() {    Animal* animals[2];    Dog dog;    Cat cat;    animals[0] = &dog;    animals[1] = &cat;    for (int i = 0; i < 2; ++i) {        animals[i]->speak();    }    return 0;}

Example 3: Real-World Analogy

#include <iostream>using namespace std;class PaymentMethod {public:    virtual void pay() {        cout << "Processing payment" << endl;    }};class CreditCard : public PaymentMethod {public:    void pay() override {        cout << "Paying with credit card" << endl;    }};class PayPal : public PaymentMethod {public:    void pay() override {        cout << "Paying with PayPal" << endl;    }};int main() {    PaymentMethod* payment;    CreditCard cc;    PayPal pp;    payment = &cc;    payment->pay(); // Outputs: Paying with credit card    payment = &pp;    payment->pay(); // Outputs: Paying with PayPal    return 0;}

Common Questions and Answers

1. What is polymorphism in C++?

   Polymorphism allows objects of different classes to be treated as objects of a common base class. The most common use of polymorphism in C++ is through virtual functions.

2. Why do we use virtual functions?

   Virtual functions allow derived classes to override methods in a base class, enabling polymorphic behavior.

3. Can constructors be virtual?

   No, constructors cannot be virtual. However, destructors can and should be virtual if you’re dealing with inheritance.

4. What happens if a derived class does not override a virtual function?

   If a derived class does not override a virtual function, the base class version is used.

5. How does polymorphism improve code flexibility?

   Polymorphism allows you to write more generic and reusable code. It enables you to call methods on objects without knowing their exact class type.

Troubleshooting Common Issues

Ensure that you declare your functions as virtual in the base class. Forgetting to do so will prevent polymorphic behavior.

If your derived class function is not being called, check if you’ve used the override keyword. It helps catch errors where the function signature doesn’t match the base class.

Always use a base class pointer or reference to achieve polymorphism. Directly using derived class objects will not demonstrate polymorphic behavior.

Practice Exercises

• Create a base class Shape with a virtual function draw(). Derive classes Circle and Square and override draw() in each. Test polymorphism by calling draw() on a Shape pointer.
• Implement a Vehicle base class with a virtual function start(). Derive classes Car and Bike and override start(). Use an array of Vehicle pointers to call start() on different objects.

For more information, check out the C++ Polymorphism Documentation.