Polymorphism in C++

What is Polymorphism in C++?

Polymorphism word is the combination of "poly," which means many + "morphs," which means forms, which together means many forms. Polymorphism in C++ is when the behavior of the same object or function is different in different contexts. Let's take a real-world example of the word right can mean different things in a different context.

• I was right. In the above sentence, the word right means "correct".
• Please take a right turn. The word right refers to the "right direction" in the above sentence.

Example Of Polymorphism in C++

The + operator in C++ is one of the best examples of polymorphism. The + operator is used to add two integers as follows :

Output:

In the above example, + is used to add $a = 10$ and $b = 32$, the output Value of $a + b$ is : 42.

However, + is also used to concatenate two string operands. The + operator is used to concatenate two strings as follows :

Output:

In the above example, + is used to concatenate two strings $a$ = poly and $b$ = morphism, therefore the output Value of $a+b$ is polymorphism.

Types of Polymorphism in C++

Following are the two types of polymorphism in C++ :

1. Compile Time Polymorphism
2. Runtime Polymorphism

Compile Time Polymorphism

Compile-time polymorphism is done by overloading an operator or function. It is also known as "static" or "early binding".

Why is it called compile-time polymorphism?

Overloaded functions are called by comparing the data types and number of parameters. This type of information is available to the compiler at the compile time. Thus, the suitable function to be called will be chosen by the C++ compiler at compilation time.

There are the following types of compile-time polymorphism in C++ :

Function Overloading

When we have two functions with the same name but different parameters, different functions are called depending on the number and data types of parameters. This is known as function overloading

Function Overloading can be achieved through the following two cases:

• The names of the functions and return types are the same but differ in the type of arguments.
• The name of the functions and return types are the same, but they differ in the number of arguments.

Let's understand with an example :

Output :

Explanation:

• In the above example, the add function is overloaded.
• t1 is the object of class Temp, t1.add(10). It will call void add(int y).
• t1.add(11.1), it will call void add(double d).
• t1.add(12,13), it will call void add(int y, int z).
• The overloaded functions are called by matching the type and number of arguments. Because this information is available at compile-time, the compiler selects the proper function based on its parameters.

Operator Overloading

When an operator is updated to be used for user-defined data types (objects etc.), this is known as operator overloading. To use operator overloading, at least one operand must be a user-defined data type.

Runtime Polymorphism

Runtime polymorphism occurs when functions are resolved at runtime rather than compile time when a call to an overridden method is resolved dynamically at runtime rather than compile time. It's also known as late binding or dynamic binding.

Runtime polymorphism is achieved using a combination of function overriding and virtual functions.

The following sections will show an example of overriding with and without the virtual keyword.

Function Overriding without Virtual Keyword

Function Overriding is when more than one method of the derived class has the same name, the same number of parameters, and the same parameter type as of base class.

Syntax :

Output:

Explanation:

• In this example, the width, height, and functions set values and area are shared by all three classes (Polygon, Rectangle, and Triangle).
• Three references to Polygon are declared in the main function (ppoly1, ppoly2, and ppoly3 ). These are given the addresses rect and trgl poly, which are objects of type Rectangle, Triangle, and Polygon, respectively. Rectangle and Triangle are Polygon-derived classes; therefore, such assignments are permitted.
• ppoly1 -> set_values (10, 20); is similar to rect.set_values (10, 20); and ppoly2 -> set_values (10, 20); is similar to trgl.set_values (10, 20);
• ppoly1 -> area() and ppoly1 -> area() is called this will call area function of the base class Polygon.
• This happens due to static linkage, which implies that the compiler only sets the call to the area() once in the base class.
• To overcome this problem, the concept of virtual pointers is introduced.

Function Overriding with Virtual Keyword

A virtual function in C++ is a base class member function. In a derived class, we can redefine it. The virtual function must be declared using the keyword virtual in the base class. A class that declares or inherits a virtual function is called a polymorphic class.

Syntax :

Output:

Explanation:

• ppoly1 -> area() is called it will call area function of Rectangle class.
• ppoly2 -> area() is called it will call area function of Triangle class.
• This is because we used the virtual keyword to make the base class Polygon method area virtual in this code. The confusion over which function to call will be resolved at runtime, resulting in the desired outcome.

Pure Virtual Function

A Pure Virtual Function is a virtual function declared in the base class without definition. In simple words, it does nothing in the base class. But the derived class must provide an implementation for this function. Otherwise, we'll get a compilation error.

Syntax :

Output:

Explanation:

• Base *b1; a pointer to an object of the base class is created.
• b1 = new Derived(), b1 is now an object of Derived class.
• b1 -> func() will call the func() of the Derived class because it was declared as a virtual function in the Base class.

Compile-Time Polymorphism Vs. Run-Time Polymorphism

Unlock the world of C++ programming with our C++ full course designed by industry experts. Enroll now and excel in coding.

See Also:

• File Handling in C++.