Why we actually need runtime polymorphism

Question

I'm attempting to grasp polymorphism, but I'm not sure why we require runtime polymorphism because static polymorphism works just well for calling class members.

Assume there was an issue.

#include <bits/stdc++.h>
using namespace std;
class base{
    public:
        virtual void fun(){
            cout<<"base called"<<endl;
        }
};
class derived:public base{
    public:
        void fun(){
            cout<<"derived called"<<endl;
        }
};
int main() {

    base b,*b1;
    derived d;
    b1 = &d;
    b1->fun();
    // b.fun();
    // d.fun();
}

If this were my code, and I wanted to access the function of a derived or base class, I could do so by simply creating an object of that class, why would we try to call the object via references? (runtime polymorphism). 

Can someone explain the actual requirement for runtime polymorphism, or, if feasible, explain it using any real-life scenarios?

Answer 1

One of the most significant elements of Object-Oriented Programming is polymorphism. Polymorphism in C++ is primarily classified into two types:

Compile-time Function overloading or operator overloading is used to accomplish this form of polymorphism.

Runtime Polymorphism: Function Overriding is used to accomplish this form of polymorphism.

Take a look at the following scenario.

Let's say we have a Shape base class with the following interface.

class Shape {
public:
    Shape(int init_x, int init_y);
    virtual ~Shape() = default;

    virtual void scale(int s) = 0;
protected:
    int x;
    int y;
};

We now wish to inherit two more classes from it: Rectangle and Circle.

class Rectangle : public Shape {
public:
    Rectangle(int init_x, int init_y, int w, int h);
    void scale(int s) override;
private:
    int width;
    int height;
};

class Circle : public Shape {
public:
    Circle(int init_x, int init_y, int r);
    void scale(int s) override;
private:
    int radius;
};

As you may know, the scale function for circle and rectangle forms is implemented differently, hence I can't implement it in the Shape class.

Assume we have a software that saves all the shapes in a vectorShape*> container. (For example, it obtains all of the user's forms at once and stores them in this container.)

We don't know which sort of shape we're working with when we use the scale method on one of the shapes, but it will link our scale method call to the proper implementation.