Polymorphism Principle

Polymorphism is one of the 4 main OOP principles. It's the ability to take many forms.

Compile time Polymorphism

Compile time Polymorphism occurs in function overloading and operator overloading.

Example of function overloading - many functions with the same name that accept different arguments:

Result:

Runtime Polymorphism

Runtime Polymorphism occurs in function overriding .

This means that the base class has a function that's being overwritten in the children classes:

#include <iostream>

using namespace std;

class Figure
{
public:
    // base class method that'll be overwritten:
    double calcArea()
    {
        return 0;
    }
};

// Square extends Figure class
class Square : public Figure
{
private:
    double side;

public:
    Square(double sideValue)
    {
        side = sideValue;
    }

// overwriting base method:
    double calcArea()
    {
        return side * side;
    }
};

// Triangle extends Figure class
class Triangle : public Figure
{
private:
    double a;
    double b;
    double c;

public:
    Triangle(double aVal, double bVal, double cVal)
    {
        a = aVal;
        b = bVal;
        c = cVal;
    }

// overwriting base method:
    double calcArea()
    {
        double p = (a + b + c) / 2;
        double area = sqrt(p * (p - a) * (p - b) * (p - c));

return area;
    }
};

void main()
{
    Square square(2);
    cout << "Square Area = " <<
        square.calcArea() << endl;

Triangle triangle(3, 4, 5);
    cout << "Triangle Area = " <<
        triangle.calcArea();
}

Output:

The function calcArea in Figure class is overwritten by Square and Triangle classes.