05
OctPolymorphism in C++: Types of Polymorphism
Polymorphism in C++: An Overview
Polymorphism in C++ is using the same functions or operators multiple times in multiple ways. In this C++ tutorial, we'll dive into this important OOPs concept in C++. It plays an important role in increasing your code reusability. Therefore, let us now discuss it in detail. For more information and hands-on consider our C++ Certification program and get a chance to become a certified C++ developer.
What is Polymorphism in C++?
Polymorphism is made up of two words, poly
means more than one and morphs
means forms. Therefore, polymorphism
means the ability to take more than one form. This property makes the same entities such as functions, and operators perform differently in different scenarios. You can perform the same task in different ways. This makes polymorphism
in C++ an important OOP concept.
Real-Life Example of Polymorphism
In the given figure, a person when a student pays his bills. After completing his studies, the same person becomes a millionaire and pays bills of various types. Here the person is the same and the function he performs is also the same. The only difference is in the type of bills.
Types of Polymorphism in C++
There are two types of polymorphism
in the C++ programming language. These are:
- Compile time Polymorphism
- Runtime Polymorphism
- Compile time Polymorphism in C++
In this, the compiler at the compilation stage knows which functions to execute during the program execution. It matches the overloaded functions or operators with the number and type of parameters at the compile time.
The compiler performs compile-time polymorphism in C++ in two ways:
- Function Overloading
- Operator Overloading
Read More - C++ Interview Interview Questions for Experienced
- Function Overloading in C++
We already saw how to use the same function with different numbers and types of parameters for different tasks in the section, C++Function Overloading.
You are also aware of inheritance in C++ very well. Therefore, we will now implement the concept of function overloading
with parent and derived classes in C++.
Example of Function Overloading in C++ Compiler
#include <iostream>
using namespace std;
class DotNetTricks {
public:
void print(int x) {
cout << "DotNetTricks was established in " << x << endl;
}
};
class ScholarHat : public DotNetTricks {
public:
void print(string message) {
cout << "ScholarHat was founded by the DotNetTricks founder, " << message << endl;
}
};
int main() {
DotNetTricks obj1;
ScholarHat obj2;
obj1.print(2015);
obj2.print("Shailendra Chauhan"); // Calls the overloaded print(string) in Derived class
return 0;
}
- The
print()
function with different parameter types is declared in both the classes,DotNetTricks
andScholarHat
. - The object
obj1
of the parent class,DotNetTricks
calls theprint()
function of the parent class with anint
argument. - The object
obj2
of the child class,ScholarHat
calls the overloadedprint()
function in the derived class with astring
argument. - Hence, we can say that the child class,
ScholarHat
has overloaded theprint()
function of the parent class,DotNetTricks
.
Output
DotNetTricks was established in 2015
ScholarHat was founded by the DotNetTricks founder, Shailendra Chauhan
- Operator Overloading in C++
Operator overloading in C++ is basically function overloading
, where different operator functions have the same symbol but different operands. And, depending on the operands, different operator functions are executed. The operands here are the user-defined data types like objects or structures
and not the basic data types.
Example of Operator Overloading in C++
#include <iostream>
#include <string>
using namespace std;
// Class to implement operator overloading for concatenating the strings
class MyString {
public:
char s1[25], s2[25];
// Parameterized Constructor
MyString(char str1[], char str2[])
{
// Initialize the string to class object
strcpy(this->s1, str1);
strcpy(this->s2, str2);
}
// + Overload Operator to concatenate the string
void operator+()
{
cout << "\nConcatenation: " << strcat(s1, s2);
}
};
int main()
{
char str1[] = "Welcome to";
char str2[] = "ScholarHat";
// Declaring and initializing the class with the above two strings
MyString overload(str1, str2);
// Call operator function
+overload;
return 0;
}
- In the above code, we have overloaded the
+
operator in theMyString
class, allowing you to concatenate twoMyString
objects. - We have concatenated
str1
andstr2
objects using the+
operator, and the result is stored in theresult
variable.
Output
Welcome to ScholarHat
- Runtime Polymorphism in C++
In this, the compiler at the compilation stage does not know the functions to execute during the program execution. The function call is not resolved during compilation, but it is resolved in the run time based on the object type. It means the function is invoked by seeing which object is calling it; the parent class object or the derived class object. This is also known as dynamic binding
or late binding
.
Runtime Polymorphism in C++ is achieved in two ways:
- Function Overriding
- Virtual Functions
- Function Overriding in C++
In this, the method with the same name, type, and number of parameters is defined in both the base and derived classes. When the object of the derived class calls this method, the method in the derived class gets executed instead of the base class. Therefore, we can say that the method of the derived class has overridden the method of the base class.
Example of Function Overriding in C++
#include <iostream>
using namespace std;
class DotNetTricks {
public:
void print() {
cout << "Welcome to DotNetTricks" << endl;
}
};
class ScholarHat : public DotNetTricks {
public:
void print() {
cout << "Welcome to ScholarHat" << endl;
}
};
int main() {
ScholarHat obj1;
// Call the print() function of the ScholarHat class
obj1.print();
return 0;
}
In the above code, the base class Scholarhat
overrides the print()
function of the parent class, DotNetTricks
. When you create an object of ScholarHat
and call its print()
function, it executes the version of the function defined in the ScholarHat
class.
Output
Welcome to ScholarHat
We can even access the overridden function of the base class using the scope resolution operator ::
and the pointer of the base class. We will see this in the next section, C++ Function Overriding.
- Virtual Function in C++
When we use the pointer of the base class to override the function of the base class in the derived class, it is not done. Therefore virtual functions
in C++ come into play. If you declare a method in the base class as virtual
and use a pointer of the base class to call that method, it calls the method of the derived class and not the base class. Thus, the virtual function
in the base class helps the derived class method to override that function.
Example of Virtual Function in C++
#include <iostream>
using namespace std;
class DotNetTricks {
public:
virtual void print() {
cout << "Welcome to DotNetTricks" << endl;
}
};
class ScholarHat : public DotNetTricks {
public:
void print() {
cout << "Welcome to ScholarHat" << endl;
}
};
int main() {
ScholarHat sobj1;
// Pointer of the Base type that points to sobj1
DotNetTricks* ptr = &sobj1;
// Calls the member function of the Derived class
ptr->print();
return 0;
}
The above C++ code in C++ Editor creates an object of ScholarHat
and uses a pointer of the base class type (DotNetTricks
) to demonstrate function overriding
. When ptr->print()
is called, it will invoke the print()
function of the ScholarHat
class due to the virtual print()
function in the DotNetTricks
class.
Output
Welcome to ScholarHat
Read more about virtual functions
in our C++ Virtual Functions tutorial
Difference between Runtime and Compile time polymorphism
Compile-time polymorphism | Runtime polymorphism |
the function to be invoked is known at the compile time | the function to be invoked is known at the run time |
It is also known as static binding, overloading, or early binding. | It is also known as late binding, overriding, or Dynamic binding. |
Overloading is a compile-time polymorphism where more than one method has the same name but with a different number of parameters or the type of the parameters. | Overriding is a run-time polymorphism where more than one method has the same name, number of parameters, and type of parameters. |
This particular polymorphism is achieved by operator overloading and function overloading. | This particular polymorphism is achieved using pointers and virtual functions. |
It is faster as the function to be invoked is known at the compile time | It is slower as the function to be invoked is known at the run time |
It is less flexible because all the execution is done at the compile time. | It is more flexible because all the execution is done at the run time. |
Summary
So here we have covered an important OOPs concept in C++, polymorphism
and its types. If you thoroughly get through the article, you will definitely understand it. It is quite confusing and difficult to understand but if you are following the sequence from OOPs concepts in C++, you won't find it that difficult. For further learning consider our C++ Certification.