C++ supports two main types of polymorphism:

1.Compile-time (Static) Polymorphism:
This type of polymorphism is resolved at compile-time. It occurs when the compiler determines which method or function to call based on the function signature and the context in which it is used. Compile-time polymorphism is achieved through function overloading and operator overloading.

a.Function Overloading:
In function overloading, multiple functions with the same name but different parameter lists are defined within the same scope. The compiler decides which function to call based on the number and types of arguments passed.

int add(int a, int b);
double add(double a, double b);

b.Operator Overloading:
Operator overloading involves defining new behaviors for existing operators, such as +, -, or =. The compiler selects the appropriate overloaded operator function based on the operands.

Complex operator+(const Complex& a, const Complex& b);

2.Run-time (Dynamic) Polymorphism:
Run-time polymorphism is resolved at runtime. It is achieved through function overriding and is often associated with inheritance. In C++, this is implemented using virtual functions and the dynamic dispatch mechanism.

a.Virtual Functions:
A virtual function is a member function of a class that can be overridden by derived classes. It allows a subclass to provide its own implementation of the function while maintaining a common interface.

class Shape {
public:
virtual void draw() const {
// Base class implementation
}
};

class Circle : public Shape {
public:
void draw() const override {
// Subclass implementation
}
};

b.Dynamic Dispatch:
When calling a virtual function on a pointer or reference to a base class, C++ uses dynamic dispatch to determine the appropriate function to invoke at runtime based on the actual object’s type.

Shape* shapePtr = new Circle();
shapePtr->draw(); // Calls the draw() function of Circle class