Polymorphism in C++

Introduction to Polymorphism

Welcome back! We're continuing our journey into object-oriented programming (OOP) with a new and exciting topic: Polymorphism. You've already learned about classes, objects, and inheritance, which are essential building blocks of OOP. Now, it's time to explore how polymorphism can make your code more flexible and reusable.

What You'll Learn

Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. This provides a way to use a single interface to represent different types of objects. Here’s what we’ll cover in this lesson:

  1. Understanding Polymorphism: We'll discuss what polymorphism is and why it's a powerful concept in C++ programming.
  2. Implementing Polymorphism in C++: You'll learn how to use virtual functions and method overriding to achieve polymorphism.

Understanding Polymorphism

Polymorphism in C++ allows you to call derived class methods through a base class pointer or reference. This can make your code more dynamic and general. For example, consider the following code snippet:

#include <iostream>
#include <string>

// Define a base class Person with name and age attributes
class Person {
public:
    Person(const std::string& name, int age) : name(name), age(age) {}

    // Define a virtual display method to signify, that it can be overridden by derived classes
    virtual void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }

private:
    std::string name;
    int age;
};

// Define a derived class Student with a major attribute
class Student : public Person {
public:
    Student(const std::string& name, int age, const std::string& major)
        : Person(name, age), major(major) {}

    // Override the display method to include the major attribute. Note that the 'override' keyword is optional but recommended for clarity.
    void display() override {
        Person::display();
        std::cout << "Major: " << major << std::endl;
    }

private:
    std::string major;
};

// Define a derived class Teacher with a subject attribute
class Teacher : public Person {
public:
    Teacher(const std::string& name, int age, const std::string& subject)
        : Person(name, age), subject(subject) {}

    // Override the display method to include the subject attribute
    void display() override {
        Person::display();
        std::cout << "Subject: " << subject << std::endl;
    }

private:
    std::string subject;
};

int main() {
    // Create instances of Student and Teacher using base class pointers
    Person* person1 = new Student("Alice", 30, "Computer Science");
    Person* person2 = new Teacher("Bob", 25, "Mathematics");

    // Call the display method on the base class pointers. The appropriate derived class method will be invoked.
    person1->display();
    person2->display();

    // Free the allocated memory to avoid memory leaks
    delete person1;
    delete person2;
    return 0;
}

In this example, the display method of the derived classes (Student and Teacher) overrides the base class method in Person. When we call display on a base class pointer (Person*), the appropriate derived class method is invoked.

Note that we need to delete the allocated memory for the base class pointers to avoid memory leaks. This is a good practice when working with pointers in C++.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal