Difference Between Compile Time And Run Time Polymorphism In C++
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:
- Compile-time Polymorphism
- 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:
- Function Overloading
- 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 <iostream> 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; } |
30 60 100
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 <iostream> 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; } |
Output 13
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 <iostream> 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; } |
derived
Difference Between Compile Time And Run Time Polymorphism
Compile-Time Polymorphism |
Run-Time Polymorphism |
---|---|
It is also called Static Polymorphism. | It is also known as Dynamic Polymorphism. |
In compile-time polymorphism, the compiler determines which function or operation to call based on the number, types, and order of arguments. | 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. |
Function calls are statically binded. | Function calls are dynamically binded. |
Compile-time Polymorphism can be exhibited by: 1. Function Overloading |
Run-time Polymorphism can be exhibited by Function Overriding. |
Faster execution rate. | Comparatively slower execution rate. |
Inheritance in not involved. | Involves inheritance. |
Contact Us