Polymorphism in C++ - PDF.co (2023)

Polymorphism means a name with many forms, in C++ polymorphism is a mechanism where the same function, name and operator can be used to work with different input parameters. Polymorphism is one of the most important features of object-oriented programming. A real world example would be a single person who has multiple roles such as father, brother, husband, friend, etc.

UsThere are two types of polymorphism in C++

• Compile-time polymorphism
• runtime polymorphism

The following diagram can give a clear overview of polymorphism and its types:

Polymorphism at compile time

C++ provides compile-time polymorphism in operators and functions called operator overloading and function overloading respectively, compile-time polymorphism is also called early binding or static binding, let's explore both.

1.1 Functional Overload

Function overloading is a polymorphism mechanism where the same function name can be called with different parameters; the parameters must differ in number or with different data types. Let's see an example:

#include<bits/stdc++.h>usando espacio de nombres std;int add(int numero1, int numero2){ return (numero1 + numero2);}float add(double numero1, double numero2){ return (numero1 + numero2); }void principal(){ cout<<añadir(5,10); cout<<adicionar(5.1,10.2);}

We can see in the example above that there are two functions with the same name as add, the first with two integer parameters and the second with two double parameters. Compiling this program in a C compiler will generate an error saying Function declaration with the same name, but in C++ this code will compile and when run add(5,10) will call the function with integer definition and add (5.1,10.2) calls add with double definition. The compiler distinguishes functions based on the mechanism calledname mutilation.

Name change:Renaming adds additional information to functions of the same name, this additional information is mainly based on function parameters, each compiler can use its own renaming technique, there is no hard and fast rule about renaming. For the example above, the C++ compiler could change the names internally and the object's code could look like this:

int add_int(int number1,int number2);float add_double(duplo number1,duplo number2);void main() cout<<add_int(5,10); cout<<add_double(5.1,10.2);}

Let's look at some examples of function overloading

example 1

#include<bits/stdc++.h> using the default namespace;int add(int number1, int number2,int number3){ return (number1 + number2 + number3);}int add(int number1, int number2){ return ( Number1 + Number 2);}

The above example has different number of parameters for both functions, now the compiler calls the functions based on the number of parameters passed, the first function calls with 3 arguments and the second with 2 arguments calling the respective functions.

example 2

usando el espacio de nombres std;int add(int number1, int number2){ return (number1 + number2);}float add(int number1, int number2){ return (number1 + number2);}void main(){ cout< <add( 5,10); cout<<adicionar(5,10);}

For the example above, the compiler throws a compilation error stating that the function call is ambiguous because both functions have the same number of parameters with the same type, although the return type is different, the function overloading mechanism does not distinguish between function calls based on return types.

Example 3

#include<bits/stdc++.h>using std namespace;int add(int number1, int number2,int number3 = 5){ return (number1 + number2 + number3);}int add(int number1, int number2){ return ( Zahl1 + Zahl2);}void main(){ cout<<add(5,10,15); cout<<add(5,10);}

For the code above, the C++ compiler issues an ambiguous declaration of a compile-error function, even though the first add function has three parameters, the last one is a default parameter, so the compiler cannot decide which function to call. The first function can also be called by passing two arguments and the second function can also be called by passing two arguments, this creates ambiguity and the compiler will throw an error during compilation.

Rules for overloading functions

• The names of the functions must be the same.
• The number of parameters passed to the function must be different, excluding default parameters, or parameters passed to functions must be of different data types (if the same parameter numbers are passed).
• Data types such as char, unsigned char, short are promoted to int and float are promoted to double.
• Functions that differ only in the return type do not support function overloading.

1.2 Operator Overload

Operator overloading is a mechanism in C++ that allows the use of an operator in a custom class. For example, we can overload the "+" operator within a class to add the content of two objects and return it to the third object.

#include<bits/stdc++.h> using the std;class namespaceComplex{ private: int real; imaginary integer; public: Complex(int ​​r, int i) { real = r; imaginary = I; } complex operator + (complex &obj){ complex result; real.result = real + real.obj; imaginary.result = imaginary + imaginary.obj; return result; } void print(){ cout<< real << "imaginary" << imaginary << endl; }}void main() { Complex c1(10,15),C2(20,25); complex c3 = c1+c2; C3.print();}Output: 30 40 imaginary

As you can see we have the functionComplex operator + (Complex &obj)This is an operator-overloaded function that is automatically called when adding two objects of the Complex class, e.g. B. c3 = c1 + c2;

The syntax of the operator overload function is as follows

<return type> operator <current operator> (parameter)

The above example shows the "+" operator used to overload operators in the same way we can overload other operators like - , *, /, <, >, = etc., but there are few operators , which cannot be overloaded like

.(Score)

Size of()

::

?:

Rules for operator overloading

• C++ compatible operators can only be overloaded.
• Operator priority remains the same.
• There must be at least one user-defined data type, we cannot just use built-in data types.
• Overloaded operators cannot include default parameters, except for the function call operator "()"
• The assignment "=", the subscript "[]", the function call "()", and the arrow operator "->" These operators must be defined as member functions, not as friend functions.
• Some operators like the assignment "=", the address "&" and the comma ""," are overloaded by default.
• The meaning of the overloaded operator should not be changed.

2.0 runtime polymorphism

C++ provides run-time polymorphism, which can be achieved through function substitution; Run-time polymorphism is also known as late binding or dynamic binding. We say a function overrides when a derived class has the same name as the function within the base class, so we call the base class function override. Let's see an example:

#include<bits/stdc++.h> using the std;class namespaceIntelligent{ public: virtual void show(){ cout<<”paint::show()”<< endl;} void draw(){ cout<<”paint::draw()”<< endl; }}KlasseKreis: public Paint { public: void show(){cout<<”circle::show()”<< endl; } void dibujar(){ cout<<”circle::draw()”<< endl; }} void main () { Malen * basePtr; Círculo derivadoObj; basePtr = &objderivado; basePtr->mostrar(); basePtr->desenhar(); vuelve 0;}Result:circle::show() paint::draw()

As we can see, basePtr->show() calls show function of derived class, since show() function is realized as virtual function in base class, virtual functions are called based on class object which is pointer of assigned is the base class, while non-virtualA function like draw() from the base class is called.

virtual function

AvirtualFunction is a function in a base class that is declared using the keywordvirtualwhich tells the compiler to use dynamic or late link mechanisms instead of static or early link mechanisms, using virtual functions we can achieve run-time polymorphism, the class that declares functions as virtual, the compiler you need to create onevirtual tableto set up the dynamic call

pure virtual function

C++ provides a pure virtual function mechanism where the virtual function in the base class is just the placeholder and doesn't implement anything, but derived classes must implement it, pure virtual functions are declared as

virtual blank() = 0

They are assigned 0; A class with all purely virtual functions is called an abstract base class

Let's wrap up the topic with the pros and cons of polymorphism.

advantages

• Reduces the burden on the programmer of remembering the different function names for the different parameters to be called; the programmer simply calls the same function with the necessary parameters.
• Polymorphism can be applied to classes and user-defined data types that define user-defined operations on user-defined data types.
• Dynamic linking helps reduce code and increase reuse.
• Polymorphism supports data abstraction.

Disadvantages

• Polymorphism is considered difficult for developers to implement.
• Run-time polymorphism increases execution time.
• Run-time polymorphism is hard to understand, less readable
• With operator overloading, the developer can change the meaning of the operator, because when "+" is overloaded, it can perform other addition operations that the compiler recognizes as errors, this way the basic meaning of the operators can be changed.
• Runtime polymorphism requires the compiler to maintain a virtual table for dynamic linking, which equates to additional memory.