Difference Between Compile Time And Run Time Polymorphism In C++ (original) (raw)

In this article, we will discuss the differences between the compile-time and runtime polymorphism in C++.

What is Polymorphism?

Poly means many and morph means forms or shape. Thus the word Polymorphism comes from Greek and it basically means having many forms.

For example,

Your DAD is your father. He's your mom's Husband. He's your grandma's son as well. Thus here your DAD is exhibiting many forms. He's a father, son, husband, brother, etc.

In C++, polymorphism can be divided into two types:

1. Compile-time Polymorphism
2. Run-time Polymorphism

Compile Time Polymorphism in C++

In compile-time polymorphism, the compiler determines which function or operation to call based on the number, types, and order of arguments. It is also called Static Polymorphism as the function calls are statically binded to its definition.

It is further categorized into two types:

1. Function Overloading
2. Operator Overloading

1. Function Overloading

When multiple functions in a class with the same name but different parameters exist, these functions are said to be overloaded.

• The functions can be overloaded by using a different number of arguments and by using different types of arguments.
• If two same name and same argument functions just vary in their return type then such function isn't overloaded.

Example

C++ `

// C++ Code to illustrate Function Overloading #include using namespace std;

// Function to be overloaded int add(int x, int y, int z = 0, int w = 0) { return (x + y + z + w); }

int main() { // Passing different number of arguements cout << add(10, 20) << endl; cout << add(10, 20, 30) << endl; cout << add(10, 20, 30, 40) << endl;

return 0;

}

`

Operator Overloading

We know that, "+" is used for addition or concatenation. Now, if I want to perform my customized operation i.e. upon calling +, I want to print "Hello Geek" or I want to perform subtraction instead of addition. In such cases, we use operator overloading.

Operator overloading is the process of defining different operations for the operator that vary depending on the argument type.

• Precedence and associativity remain intact in operators.
• List of operators that cannot be overloaded in C++ are ::, .*, ., ?:
• Operators = and & are already overloaded in C++, so we should avoid overloading them.

Example

C++ `

// C++ Code to illustrate Operator Overloading #include using namespace std;

class B { public: int a, b;

public: int add() { return a + b; }

// overloading + operator for B class
void operator+(B& obj)
{
    int val1 = this->a;
    int val2 = obj.a;
    cout << "Output " << val2 - val1 << endl;
}

};

// driver code int main() { B obj1, obj2; obj1.a = 4; obj2.a = 17; obj1 + obj2; return 0; }

`

Run Time Polymorphism

In run-time polymorphism, the decision of which function to call is determined at runtime based on the actual object type rather than the reference or pointer type. It is also known as Dynamic Polymorphism because the function calls are dynamically bonded at the runtime.

Run Time Polymorphism can be exhibited by:

• Method Overriding using Virtual Functions

Method Overriding

Method overriding refers to the process of creating a new definition of a function in a derived class that is already defined inside its base class. Some rules that must be followed while overriding a method are:

• Method names must be the same.
• Method parameters must be the same.

Virtual Function

• Virtual Function is a member function that is declared as virtual in the base class and it can be overridden in the derived classes that inherit the base class.
• Virtual functions are generally declared in the base class and are typically defined in both the base and derived classes.

Example

C++ `

// C++ Code to illustrate Virtual Function #include using namespace std;

// base class class Base { public: // virtual function virtual void print() { cout << "base"; } };

// derived class class Derived : public Base { public: // method overriding void print() override { cout << "derived"; } };

// driver code int main() { Base* obj = new Derived(); obj->print(); delete obj; return 0; }

`

Difference Between Compile Time And Run Time Polymorphism