{"id":10481,"date":"2025-03-19T09:00:00","date_gmt":"2025-03-19T04:00:00","guid":{"rendered":"https:\/\/afzalbadshah.com\/?p=10481"},"modified":"2026-03-30T09:02:49","modified_gmt":"2026-03-30T04:02:49","slug":"polymorphism-in-c-oop-tutorial-with-real-life-examples","status":"publish","type":"post","link":"https:\/\/afzalbadshah.com\/index.php\/2025\/03\/19\/polymorphism-in-c-oop-tutorial-with-real-life-examples\/","title":{"rendered":"Polymorphism in C++ | OOP Tutorial with Real-Life Examples"},"content":{"rendered":"\n

Polymorphism is one of the four core concepts of Object-Oriented Programming (OOP), along with encapsulation, inheritance, and abstraction. The term polymorphism is derived from two Greek words; poly (many) and morph (forms). In programming, it means one name, many forms. In simple words, polymorphism allows a single function, operator, or object to behave differently based on the context. This makes our code flexible, reusable, and easy to extend.<\/p>\n\n\n\n

Understanding Polymorphism<\/h2>\n\n\n\n

Think about the word \u201cdrive\u201d<\/strong>.
A car<\/strong> drives, a bike<\/strong> drives, and a bus<\/strong> drives. The action \u201cdrive\u201d is the same, but the behavior is different depending on the object. This is polymorphism; the same operation acting differently for different entities.<\/p>\n\n\n\n

Similarly, in a company, the manager, designer, and developer all respond to the command \u201cWork!\u201d<\/strong>, but each performs a different task. This is how polymorphism works in real life and also in programming.<\/p>\n\n\n\n

What Is Polymorphism in C++<\/h2>\n\n\n\n

Polymorphism in C++ is the ability of a function, operator, or object to take many forms. It allows the same function name to perform different tasks depending on the type of object or the number of parameters. Polymorphism provides the foundation for dynamic behavior in software, allowing us to write programs that can adapt at runtime.<\/p>\n\n\n\n

\"\"
Types of Polymorphism<\/figcaption><\/figure>\n\n\n\n

Types of Polymorphism in C++<\/h2>\n\n\n\n

C++ supports two main types of polymorphism:<\/p>\n\n\n\n

Type<\/th>Description<\/th>Example<\/th><\/tr><\/thead>
Compile-Time Polymorphism (Static)<\/strong><\/td>Decided by the compiler during compilation.<\/td>Function Overloading, Operator Overloading<\/td><\/tr>
Run-Time Polymorphism (Dynamic)<\/strong><\/td>Decided during program execution.<\/td>Virtual Functions \/ Function Overriding<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Compile-Time (Static) Polymorphism<\/h2>\n\n\n\n

Compile-time polymorphism means the decision about which function to call is made before the program runs. This is achieved using function overloading and operator overloading.<\/p>\n\n\n\n

\"\"
Function overloading<\/figcaption><\/figure>\n\n\n\n

Function Overloading Example<\/h3>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nclass Math {\npublic:\n    int add(int a, int b) {\n        return a + b;\n    }\n\n    double add(double a, double b) {\n        return a + b;\n    }\n\n    int add(int a, int b, int c) {\n        return a + b + c;\n    }\n};\n\nint main() {\n    Math m;\n    cout << \"Sum of two integers: \" << m.add(2, 3) << endl;\n    cout << \"Sum of two doubles: \" << m.add(2.5, 3.8) << endl;\n    cout << \"Sum of three integers: \" << m.add(1, 2, 3) << endl;\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
Operator Overloading Example<\/h3>\n\n\n\n
\"\"
Operator Overloading<\/figcaption><\/figure>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nclass Plot {\n    int length, width;\n\npublic:\n    \/\/ Constructor\n    Plot(int l = 0, int w = 0) {\n        length = l;\n        width = w;\n    }\n\n    \/\/ Operator overloading (+)\n    Plot operator + (Plot p) {\n        Plot temp;\n        temp.length = length + p.length;\n        temp.width  = width + p.width;\n        return temp;\n    }\n\n    \/\/ Display function\n    void display() {\n        cout << \"Plot: \" << length << \" x \" << width << endl;\n        cout << \"Area: \" << length * width << endl;\n    }\n};\n\nint main() {\n    \/\/ Create two plots\n    Plot p1(10, 5);\n    Plot p2(6, 3);\n\n    \/\/ Add plots using overloaded operator\n    Plot p3 = p1 + p2;\n\n    \/\/ Display result\n    cout << \"Combined Plot:\\n\";\n    p3.display();\n\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
Run-Time (Dynamic) Polymorphism<\/h2>\n\n\n\n
Run-time polymorphism means the function that gets executed is determined at runtime, not compile time. This is achieved through function overriding using virtual functions and pointers\/references to base classes.<\/p>\n\n\n\n
Function Overriding Example<\/h3>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nclass Animal {\npublic:\n    virtual void sound() {\n        cout << \"Animal makes a sound\" << endl;\n    }\n};\n\nclass Dog : public Animal {\npublic:\n    void sound() {\n        cout << \"Dog barks\" << endl;\n    }\n};\n\nclass Cat : public Animal {\npublic:\n    void sound() {\n        cout << \"Cat meows\" << endl;\n    }\n};\n\nint main() {\n    Animal* a;   \/\/ Base class pointer\n    Dog d;\n    Cat c;\n\n    a = &d;\n    a->sound();   \/\/ Calls Dog\u2019s sound()\n\n    a = &c;\n    a->sound();   \/\/ Calls Cat\u2019s sound()\n\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
Why Do We Use Pointers in Polymorphism?<\/h3>\n\n\n\n
When we call a virtual function using an object (e.g., obj.sound()<\/code>), the compiler already knows its type, so it doesn\u2019t check at runtime. But when we call it through a base class pointer or reference, C++ checks which object the pointer actually refers to and calls the correct version. Hence, pointers or references are used to achieve real dynamic behavior.<\/p>\n\n\n\n
Difference Between Function Overloading and Function Overriding<\/h2>\n\n\n\n
Feature<\/th>Function Overloading<\/th>Function Overriding<\/th><\/tr><\/thead>
Type<\/td>Compile-time polymorphism<\/td>Run-time polymorphism<\/td><\/tr>
Parameters<\/td>Must differ<\/td>Must be same<\/td><\/tr>
Inheritance<\/td>Not required<\/td>Required<\/td><\/tr>
Keyword<\/td>No keyword needed<\/td>Uses virtual<\/code> keyword<\/td><\/tr>
Execution Time<\/td>Decided at compile time<\/td>Decided at runtime<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Real-World Example: Draw Function<\/h2>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nclass Shape {\npublic:\n    virtual void draw() {\n        cout << \"Drawing a shape\" << endl;\n    }\n};\n\nclass Circle : public Shape {\npublic:\n    void draw() {\n        cout << \"Drawing a circle\" << endl;\n    }\n};\n\nclass Rectangle : public Shape {\npublic:\n    void draw() {\n        cout << \"Drawing a rectangle\" << endl;\n    }\n};\n\nint main() {\n    Shape* shape;\n    Circle c;\n    Rectangle r;\n\n    shape = &c;\n    shape->draw();\n\n    shape = &r;\n    shape->draw();\n\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
Output:<\/strong><\/p>\n\n\n\n
Drawing a circle\nDrawing a rectangle\n<\/code><\/pre>\n\n\n\n
Advantages of Polymorphism<\/h2>\n\n\n\n
    \n
  1. Code Reusability:<\/strong> Once a base class or function is written, it can be reused by derived classes without rewriting code. This reduces redundancy and saves development time.<\/li>\n\n\n\n
  2. Flexibility:<\/strong> Polymorphism allows one interface to handle multiple types of behavior. For example, a single pointer of a base class can call different functions depending on which derived object it points to.<\/li>\n\n\n\n
  3. Scalability:<\/strong> New classes and behaviors can be added easily without modifying existing code. This makes software easier to extend and maintain.<\/li>\n\n\n\n
  4. Readability:<\/strong> Code becomes more organized and easier to understand since similar actions are grouped under the same interface or function name.<\/li>\n<\/ol>\n\n\n\n
    Key Points to Remember<\/h2>\n\n\n\n