Welcome to our guide on Polymorphism In C++ and its various types.
If you're wondering, \"What is Polymorphism in C++?\" or seeking to explore the complexity of this powerful concept, you're in the right place. <\/p>\n\n\n\n
In this blog, we delve into the fundamentals of Polymorphism in C++ and explain how it allows for versatility and efficiency in programming. <\/p>\n\n\n\n
From virtual functions to differences between runtime and compile-time, we'll break down key techniques with Polymorphism in C++ examples <\/strong>that enable you to write adaptable and reusable code. <\/p>\n\n\n\n Whether you're just starting or a professional programmer, this blog is your go-to resource for mastering Polymorphism in C++.<\/p>\n\n\n\n Join our \"Introduction to C++<\/a>\" course and build a strong foundation in programming that will serve you throughout your career!<\/p>\n\n\n\n \n C++ Programming Course<\/a>\n <\/p>\n Master key C++ programming concepts like variables, functions, OOP, and control structures. Build real-world projects such as a banking system and grade management tool.<\/p>\n Polymorphism in C++ refers to the ability of objects to take on multiple forms based on their context or usage. It allows different objects to respond to the same message differently. Explore a variety of \"C++ Projects To Work On In 2024<\/a>\" and find the perfect project to showcase your skills.<\/p>\n\n\n\n In C++, two primary types of Polymorphism are:<\/p>\n\n\n\n Now, let's delve deeper into these types of Polymorphism in C++ and explore how they contribute to flexibility and extensibility.<\/p>\n\n\n\n Compile-time Polymorphism refers to the mechanism in C++ where the compiler determines which function to call during compilation based on the function's signature and the context in which it is invoked. This is typically achieved through function overloading and operator overloading.<\/p>\n\n\n\n Function overloading occurs when multiple functions have the same name but different parameters. Here's an example of function overloading in C++:<\/p>\n\n\n Output<\/strong><\/p>\n\n\n Explaination<\/strong><\/p>\n\n\n\n In this example, the ' In C++, operator overloading empowers operators to have special meanings for specific data types. For instance, we can redefine the addition operator (+) for the string class to concatenate two strings. This flexibility allows us to extend the functionality of operators beyond their conventional usage.<\/p>\n\n\n\n Here's an example showcasing operator overloading in C++:<\/p>\n\n\n Output<\/strong><\/p>\n\n\n Explanation<\/strong><\/p>\n\n\n\n This code snippet defines a 'StringConcat'<\/strong> class with a member variable str of type string. We then overload the addition operator + inside the class. Need More clarity on operator overloading in C++? Runtime Polymorphism in C++, also known as late binding or dynamic Polymorphism, is achieved through function overriding. Function overriding occurs when a derived class provides a specific implementation for a function already defined in its base class. This allows objects of the derived class to use their version of the function, providing a way to achieve runtime Polymorphism.<\/p>\n\n\n\n Here's an example demonstrating function overriding in C++ related to car colors:<\/p>\n\n\n Output<\/strong><\/p>\n\n\n Explanation<\/strong><\/p>\n\n\n\n This code has a base class Car with a virtual function 'displayColor()'<\/strong>. Two derived classes, RedCar<\/strong> and BlueCar<\/strong>, override this function to provide their implementations of displaying the car color. Also, read \"Function Overloading in C++ With Examples - 2024<\/a>\" to learn how to create cleaner and more readable C++ code!<\/p>\n\n\n\n A virtual function is a member function declared within a base class that is redefined (or overridden) in a derived class. It allows the derived class to provide its implementation of the function, which is invoked based on the actual object type during runtime. Key Points To Remember:<\/strong><\/p>\n\n\n\n Example: Car Brands<\/strong><\/p>\n\n\n Output<\/strong><\/p>\n\n\n Explanation<\/strong><\/p>\n\n\n\n In this example, we have a base class Car with a virtual function 'displayBrand()<\/strong>'. Two derived classes, Ford and Toyota, override this function to provide their implementations of displaying the car brand. Also don't miss out on our guide on \"Templates in C++ With Examples | 2024<\/a>\"<\/p>\n\n\n\nDefine Polymorphism In C++<\/strong><\/strong>?<\/h2>\n\n\n\n
Like real-life scenarios where a person can exhibit various roles simultaneously, such as being a parent, spouse, and employee, C++ Polymorphism enables objects to exhibit different behaviors depending on the situation.
This feature is integral to Object-Oriented Programming and enhances code flexibility and reusability.<\/p>\n\n\n\nTypes of polymorphism In C++<\/strong><\/strong><\/h2>\n\n\n\n
\n
1. Compile Time Polymorphism <\/strong><\/h4>\n\n\n\n
A. Function Overloading<\/strong><\/h3>\n\n\n\n
This enables the same function name to perform various tasks based on the parameters provided, which can vary in number or type.
It's a feature of object-oriented programming that allows for creating multiple functions with the same name but different parameter lists.<\/p>\n\n\n\n\n#include <iostream>\nusing namespace std;\n\nclass Overload {\npublic:\n void print(int num) {\n cout << "Printing integer: " << num << endl;\n }\n\n void print(double num) {\n cout << "Printing double: " << num << endl;\n }\n\n void print(string text) {\n cout << "Printing string: " << text << endl;\n }\n};\n\nint main() {\n Overload obj;\n \n obj.print(5);\n obj.print(10.5);\n obj.print("Hello World");\n \n return 0;\n}\n<\/pre><\/div>\n\n\n\nPrinting integer: 5\nPrinting double: 10.5\nPrinting string: Hello World\n<\/pre><\/div>\n\n\n
Overload<\/code> class<\/strong>' demonstrates function overloading. It contains three 'print<\/strong><\/code>' functions, each with a different parameter type (int, double, string<\/strong>).
When the 'print<\/strong><\/code><\/code> function is called with different arguments, the appropriate version of the function is invoked based on the parameter type.
This demonstrates compile-time Polymorphism, as the decision of which function to call is made by the compiler at compile time based on the function's signature.<\/p>\n\n\n\nB. Operator Overloading<\/strong><\/h3>\n\n\n\n
\n#include <iostream>\n#include <string>\nusing namespace std;\n\nclass StringConcat {\nprivate:\n string str;\npublic:\n StringConcat() : str("") {}\n StringConcat(string s) : str(s) {}\n\n StringConcat operator+(const StringConcat& obj) {\n StringConcat result;\n result.str = this->str + obj.str;\n return result;\n }\n\n void display() {\n cout << "Concatenated String: " << str << endl;\n }\n};\n\nint main() {\n StringConcat str1("Hello");\n StringConcat str2("World");\n\n StringConcat result = str1 + str2;\n result.display();\n\n return 0;\n}\n<\/pre><\/div>\n\n\n\nConcatenated String: HelloWorld\n<\/pre><\/div>\n\n\n
When two 'StringConcat'<\/strong> objects are added using the +<\/strong> operator, the overloaded operator function is invoked, which concatenates the string members of both objects.
Finally, the concatenated string is displayed. This illustrates how operator overloading in C++ enables us to redefine the behavior of operators for custom data types, providing greater flexibility and readability in code.<\/p>\n\n\n\n
Explore our guide: \"Operator Overloading in C++ with Examples | 2024<\/a>\"<\/p>\n\n\n\n2. Runtime Polymorphism<\/strong><\/h3>\n\n\n\n
Unlike compile-time Polymorphism, where the function call is resolved at compile time, run time Polymorphism in C++ resolves the function call at runtime.
This allows for greater flexibility as the specific function implementation is determined based on the actual object type during program execution.<\/p>\n\n\n\nA. Function overriding<\/strong><\/h3>\n\n\n\n
\n#include <iostream>\n#include <string>\nusing namespace std;\n\nclass Car {\npublic:\n virtual void displayColor() {\n cout << "The car is colored in default color." << endl;\n }\n};\n\nclass RedCar : public Car {\npublic:\n void displayColor() override {\n cout << "The car is colored red." << endl;\n }\n};\n\nclass BlueCar : public Car {\npublic:\n void displayColor() override {\n cout << "The car is colored blue." << endl;\n }\n};\n\nint main() {\n Car* car1 = new RedCar();\n Car* car2 = new BlueCar();\n\n car1->displayColor();\n car2->displayColor();\n\n delete car1;\n delete car2;\n\n return 0;\n}\n<\/pre><\/div>\n\n\n\nThe car is colored red.\nThe car is colored blue.\n<\/pre><\/div>\n\n\n
In the main()<\/strong> function, we create pointers to objects of type Car pointing to instances of RedCar and BlueCar. When calling the displayColor()<\/strong> function through these pointers, the appropriate overridden version of the function is invoked based on the actual object type, demonstrating runtime Polymorphism.<\/p>\n\n\n\nB. Virtual Function<\/strong><\/h3>\n\n\n\n
This enables runtime Polymorphism, where the appropriate function implementation is selected dynamically based on the object's type rather than statically at compile time.<\/p>\n\n\n\n\n
\n#include <iostream>\n#include <string>\nusing namespace std;\n\nclass Car {\npublic:\n virtual void displayBrand() {\n cout << "This is a generic car." << endl;\n }\n};\n\nclass Ford : public Car {\npublic:\n void displayBrand() override {\n cout << "This is a Ford car." << endl;\n }\n};\n\nclass Toyota : public Car {\npublic:\n void displayBrand() override {\n cout << "This is a Toyota car." << endl;\n }\n};\n\nint main() {\n Car* car1 = new Ford();\n Car* car2 = new Toyota();\n\n car1->displayBrand();\n car2->displayBrand();\n\n delete car1;\n delete car2;\n\n return 0;\n}\n<\/pre><\/div>\n\n\n\nThis is a Ford car.\nThis is a Toyota car.\n<\/pre><\/div>\n\n\n
We create pointers for objects of type, pointing to instances of Ford<\/strong> and Toyota<\/strong> in the 'main()<\/strong>' function. When calling the 'displayBrand()<\/strong>' function through these pointers, the appropriate overridden version of the function is invoked based on the actual object type, demonstrating runtime Polymorphism.<\/p>\n\n\n\nDifference Between Runtime & Compile-Time<\/strong><\/h2>\n\n\n\n
Feature<\/strong><\/td> Compile-Time Polymorphism<\/strong><\/strong><\/td> Runtime Polymorphism<\/strong><\/td><\/tr> Definition<\/strong><\/strong><\/td> Compile time Polymorphism in C++ determines which function or operation to call based on the number, types, and order of arguments.<\/td> The decision of which function to call is determined at runtime based on the actual object type rather than the reference or pointer type.<\/td><\/tr> Binding<\/strong><\/td> Static binding, where the function calls are statically bound to their definitions.<\/td> Dynamic binding, where the function calls are dynamically bound to their definitions.<\/td><\/tr> Polymorphism Type<\/strong><\/strong><\/td> Compile-time Polymorphism, also known as static or early binding Polymorphism.<\/td> Runtime Polymorphism, also known as late binding or dynamic Polymorphism.<\/td><\/tr> Function Overloading<\/strong><\/strong><\/td> Multiple functions have the same name but different parameters defined. The compiler determines which function to call based on the number and types of arguments.<\/td> Not applicable.<\/td><\/tr> Operator <\/strong><\/td> Overloading Operators can be overloaded to perform different operations based on the types of operands.<\/td> Not applicable.<\/td><\/tr> Inheritance<\/strong><\/strong><\/td> Not involved.<\/td> Involves inheritance, where a derived class overrides a function from its base class.<\/td><\/tr> Execution Speed<\/strong><\/td> Faster execution rate, as the compiler determines which function to call at compile-time.<\/td> Comparatively slower execution rate, as the decision of which function to call is made at runtime.<\/td><\/tr> Code Reusability<\/strong><\/strong><\/td> High code reusability, as the same function name can be used with different parameters.<\/td> High code reusability, as the same function name can be used with different object types.<\/td><\/tr> Polymorphism In C++<\/strong><\/strong><\/td> Compile-time Polymorphism is achieved by function overloading of operator overloading.<\/td> Runtime Polymorphism is achieved by function overriding.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Wrapping Up<\/strong><\/h2>\n\n\n\n