This article covers polymorphism and its types in C++ with examples. Let’s start!!!<\/p>\n
The literal meaning of Polymorphism is to have many forms. In programming, this means that the same entity acts in different ways depending on situations. Polymorphism is a key concept of OOPs.<\/p>\n
Consider yourself as a real life example of polymorphism. Depending on situations, you perform different roles like a student, a son\/daughter, a brother\/sister, etc.<\/p>\n
There are two types of polymorphism in C++:<\/p>\n
This type of polymorphism is also referred to as static binding or early binding. It takes place during compilation.
\nWe use function overloading and operator overloading to achieve compile-time polymorphism.<\/p>\n
In C++, two or more functions can have the same name if the number and\/or type of parameters are different, this is called function overloading. Thus, overloaded functions are functions that have the same name but different parameters.<\/p>\n
An overloaded function is called based on the number and type of parameters passed. Thus, the compiler picks the correct function during compilation of the program.<\/p>\n
Examples of overloaded functions<\/strong><\/p>\n Example to illustrate function overloading in C++<\/strong><\/p>\n Output<\/strong><\/p>\n We can also overload operators in C++. We can change the behavior of operators for user-defined types like objects and structures.<\/p>\n For example, the \u2018+\u2019 operator, used for addition, can also be used to concatenate two strings of std::string class. Its behavior will depend on the operands.<\/p>\n Example of Operator Overloading in C++<\/strong><\/p>\n Output<\/strong><\/p>\n Run-time polymorphism takes place when functions are invoked during run time. It is also known as dynamic binding or late binding. Function overriding is used to achieve run-time polymorphism.<\/p>\n When a member function of a base class is redefined in its derived class with the same parameters and return type, it is called function overriding in C++. The base class function is said to be overridden.<\/p>\n The function call is resolved during run time and not by the compiler.<\/p>\n Example to illustrate function overriding in C++<\/strong><\/p>\n Output<\/strong><\/p>\n A virtual function is a function defined in the base class with virtual keyword. The purpose of virtual function is to ensure that the function is overridden.<\/p>\n If we do not use virtual keyword with the base class function, it may not be overridden. We can still access it using a base class pointer. If the base class pointer points to the derived class object, the base class function will get executed.<\/p>\n Let\u2019s see an example to understand this.<\/p>\n Example to illustrate the need of virtual function for function overriding in C++<\/strong><\/p>\n Output<\/strong><\/p>\n Example of run-time polymorphism using two derived classes<\/strong><\/p>\n Output<\/strong><\/p>\n Run-time polymorphism can also be achieved through data members.<\/p>\n Example of run-time polymorphism with data members<\/strong><\/p>\n Output<\/strong><\/p>\n In this article, we learnt about polymorphism in C++. There are two types of polymorphism in C++, compile-time and run-time polymorphism. Function overloading and operator overloading are used to achieve compile-time polymorphism.<\/p>\n Function overriding is used to achieve run-time polymorphism. We learnt these with the use of suitable examples. We also understood the need of virtual functions for function overriding. Lastly, we listed the differences in the two types of polymorphism.<\/p>\n","protected":false},"excerpt":{"rendered":" This article covers polymorphism and its types in C++ with examples. Let’s start!!! What is Polymorphism? The literal meaning of Polymorphism is to have many forms. In programming, this means that the same entity...<\/p>\n","protected":false},"author":1,"featured_media":81816,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3405],"tags":[3770,3771,3772,3773],"class_list":["post-81731","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cpp","tag-compile-time-polymorphism-in-c","tag-polymorphism-in-c","tag-run-time-polymorphism-in-c","tag-virtual-function-in-c"],"yoast_head":"\nint add(int, int);\nint add(int, int, int);\t\t\/\/number of parameters different\ndouble add(double, double);\t\t\/\/type of parameters different\n<\/pre>\n
#include <iostream>\nusing namespace std;\n\nint add(int a, int b) {\n return a+b;\n}\n\nint add(int a, int b, int c) {\n return a+b+c;\n}\n\ndouble add(double a, double b) {\n return a+b;\n}\n\nint main() {\n int x = 3, y = 7, z = 12;\n double n1 = 4.56, n2 = 13.479;\n \n cout<<\"x+y = \"<<add(x,y)<<endl;\n cout<<\"x+y+z = \"<<add(x,y,z)<<endl;\n cout<<\"n1+n2 = \"<<add(n1,n2);\n \n return 0;\n}\n<\/pre>\n
\nx+y+z = 22
\nn1+n2 = 18.039<\/div>\nb. Operator Overloading in C++<\/h5>\n
\/\/Using + operator to add complex numbers\n#include <iostream>\nusing namespace std;\n\nclass complex {\n private:\n float real, imag;\n public:\n complex(float r=0, float i=0){\n real = r;\n imag = i;\n }\n complex operator + (complex const &obj) {\n complex result;\n result.real = real + obj.real;\n result.imag = imag + obj.imag;\n return result;\n }\n void display() {\n cout<<real<<\"+i\"<<imag<<endl;\n }\n};\n\nint main() {\n complex c1(12.4,6), c2(7.9,8);\n complex c3 = c1 + c2;\n c3.display();\n return 0;\n}\n<\/pre>\n2. Run-time Polymorphism in C++<\/h4>\n
a. Function Overriding in C++<\/h5>\n
#include <iostream>\nusing namespace std;\n\nclass base {\n public:\n virtual void display() {\n cout<<\"Function of base class\"<<endl;\n }\n};\nclass derived : public base {\n public:\n void display() {\n cout<<\"Function of derived class\"<<endl;\n }\n};\n\nint main() {\n derived d1;\n d1.display();\n return 0;\n}\n<\/pre>\nVirtual Function in C++<\/h4>\n
#include <iostream>\nusing namespace std;\n\nclass base {\n public:\n void display() {\n cout<<\"Function of base class\"<<endl;\n }\n};\nclass derived : public base {\n public:\n void display() {\n cout<<\"Function of derived class\"<<endl;\n }\n};\n\nint main() {\n derived d;\n base *b = &d; \/\/base class pointer\n b->display(); \/\/base class function executes\n return 0;\n}\n<\/pre>\n#include <iostream>\nusing namespace std;\n\nclass Polygon {\n public:\n virtual void show() {\n cout<<\"Its a polygon\"<<endl;\n }\n};\nclass Triangle : public Polygon {\n public:\n void show() {\n cout<<\"Triangle is 3 sided polygon\"<<endl;\n }\n};\nclass Rectangle : public Polygon {\n public:\n void show() {\n cout<<\"Rectangle is 4 sided polygon\"<<endl;\n }\n};\n\nint main() {\n Polygon *p;\n Triangle t;\n Rectangle r;\n p = &t;\n p->show();\n p = &r;\n p->show();\n return 0;\n}\n<\/pre>\n
\nRectangle is 4 sided polygon<\/div>\nRun-time Polymorphism with Data Members<\/h3>\n
#include <iostream>\n#include <string>\nusing namespace std;\n\nclass Animal {\n public:\n string name = \"Animal\";\n};\nclass Dog : public Animal {\n public:\n string name = \"Dog\";\n};\n\nint main() {\n Dog d;\n cout<<d.name;\n return 0;\n}\n<\/pre>\nC++ Compile-time Polymorphism vs Run-time Polymorphism<\/h3>\n
\n\n
\n Compile-time Polymorphism<\/b><\/td>\n Run-time Polymorphism<\/b><\/td>\n<\/tr>\n \n Also called static or early binding.<\/span><\/td>\n Also called dynamic or late binding.<\/span><\/td>\n<\/tr>\n \n Achieved through overloading.<\/span><\/td>\n Achieved through overriding.<\/span><\/td>\n<\/tr>\n \n The function to be executed is known during compile time.<\/span><\/td>\n The function to be executed is known during run time.<\/span><\/td>\n<\/tr>\n \n Faster is execution.<\/span><\/td>\n Slow in execution.<\/span><\/td>\n<\/tr>\n \n Provides less flexibility.<\/span><\/td>\n Provides more flexibility.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Summary<\/h3>\n