Polymorphism Basics in C++ | CodeSignal Learn

Polymorphism Basics in C++ | CodeSignal Learn

Lesson Introduction

Polymorphism is a key concept in C++ that allows objects from different classes to be treated as objects of a shared base class. It makes your code more flexible and reusable. The term "polymorphism" stems from Greek words meaning "many forms." Our goal in this lesson is to understand the basics of polymorphism in C++ by working with a chess example.

What is Polymorphism and Why Do We Need It?

Polymorphism allows you to design and implement programs that are more flexible and easier to extend over time. It enables one interface to be used for a general class of actions, with specific actions determined by the exact nature of the situation. In C++, polymorphism is primarily achieved through the use of base class pointers or references to invoke methods in derived classes. This makes it possible to write code that can work with objects of different types and classes in a unified way. Sounds difficult? It really isn't! Let's see an example, it will help you understand the idea.

Define an Abstract Class: `ChessPiece`

An abstract class in C++ is a class that cannot be instantiated on its own and is designed to be inherited by other classes. It serves as a blueprint for derived classes. An abstract class typically includes one or more pure virtual functions. A pure virtual function is a function declaration that is specified in the base class but has no implementation in that class. Instead, it must be implemented by any non-abstract derived class. This is done by assigning 0 to the function declaration in the base class. Additionally, it's a good practice to have a virtual destructor in an abstract class. This ensures that the destructor for derived classes will be called correctly, preventing memory leaks. We'll define an abstract class ChessPiece with a pure virtual function draw and a virtual destructor. This function will be overridden by derived classes. C++#include <iostream> class ChessPiece { public: virtual ~ChessPiece() {} // Virtual destructor virtual void draw() const = 0; // Pure virtual function }; Here, ChessPiece serves as a blueprint for all chess pieces, and draw is a method that each piece must implement. Note that you can't create an instance of a class having at least one pure virtual function, because this class is abstract. For example, this is not allowed: C++int main() { ChessPiece abstract_piece = new ChessPiece(); abstract_piece->draw(); } This code will cause an error.

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

Derive Classes `Pawn` and `Knight` from `ChessPiece`

Next, we'll create two derived classes, Pawn and Knight, which will implement the draw method. class Pawn : public ChessPiece { public: void draw() const override { std::cout << "_Pawn_" << std::endl; } }; class Knight : public ChessPiece { public: void draw() const override { std::cout << "_Knight_" << std::endl; } }; Here, both classes Pawn and Knight provide their own implementations of the draw method.

Store`Pawn` Objects and `Knight` Objects in One Array

What if we want to create an array to store all the chess pieces? Using pointers to the base class allows you to create an array capable of holding objects of any derived class. This is crucial because C++ is a statically-typed language, and the compiler needs to know the type and size of each array element at compile-time. By storing pointers to the base class, you enable the compiler to treat all array elements as having the same type—pointers to the base class—thus achieving polymorphic behavior. Let's see an example: int main() {ChessPiece* pieces[10]; // Array of base class pointers for (int i = 0; i < 8; ++i) {pieces[i] = new Pawn();} for (int i = 8; i < 10; ++i) {pieces[i] = new Knight();} Here, we create an array pieces of ChessPiece pointers. Both Pawn and Knight are derived from the ChessPiece, so both can be initialized with a ChessPiece* pointer. The code shows how to store 8 Pawn objects and 2 Knight objects in this array.

Call the `draw` Method for Each Object in the Array

Finally, we'll loop through the array and call the draw method on each object. This demonstrates polymorphic behavior. for (int i = 0; i < 10; ++i) {pieces[i]->draw(); // Calls appropriate overridden function} for (int i = 0; i < 10; ++i) {delete pieces[i]; // Clean up the heap-allocated memory} return 0;} In this loop, each pieces[i]->draw() call invokes the draw method for the appropriate Pawn or Knight object. This way, we have a uniform code to work with each object. You can add more pieces of different types, and you won't need to modify this draw loop - it will automatically call the appropriate draw method for each piece.

Non-abstract Base Class

Polymorphism works even when the base class is not abstract. Let's take a look at this example: class ChessPiece { public: virtual void draw() { std::cout << "Can't draw an abstract piece!" << std::endl; } virtual ~ChessPiece() {} // Virtual destructor }; class Pawn : public ChessPiece { public: void draw() { std::cout << "_Pawn_" << std::endl; } }; class Knight : public ChessPiece { public: void draw() { std::cout << "_Knight_" << std::endl; } }; It will work in exactly the same way. But in this case, the ChessPiece class is not abstract, as its only method, draw, is defined. We can create instances of the ChessPiece class and operate them.

C++

class Pawn : public ChessPiece {
public:
    void draw() const override {
        std::cout << "_Pawn_" << std::endl;
    }
};

class Knight : public ChessPiece {
public:
    void draw() const override {
        std::cout << "_Knight_" << std::endl;
    }
};

C++

int main() {
    ChessPiece* pieces[10]; // Array of base class pointers

    for (int i = 0; i < 8; ++i) {
        pieces[i] = new Pawn();
    }

    for (int i = 8; i < 10; ++i) {
        pieces[i] = new Knight();
    }

C++

    for (int i = 0; i < 10; ++i) {
        pieces[i]->draw(); // Calls appropriate overridden function
    }

    for (int i = 0; i < 10; ++i) {
        delete pieces[i]; // Clean up the heap-allocated memory
    }

    return 0;
}

C++

class ChessPiece {
public:
    virtual void draw() {
        std::cout << "Can't draw an abstract piece!" << std::endl;
    }

    virtual ~ChessPiece() {}  // Virtual destructor
};

class Pawn : public ChessPiece {
public:
    void draw() {
        std::cout << "_Pawn_" << std::endl;
    }
};

class Knight : public ChessPiece {
public:
    void draw() {
        std::cout << "_Knight_" << std::endl;
    }
};