"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", em: "em", h3: "h3", li: "li", p: "p", pre: "pre", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {CodeBlock, ComparisonTable, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, Intuition, KeyPoints, MCQ, SubTopicHeader, TopicOverview} = _components; if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!Intuition) _missingMdxReference("Intuition", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "4.3", title: "Introduction of Polymorphism, Types of Polymorphism" }), "\n", _jsxs(TopicOverview, { title: "Introduction to Polymorphism and Its Types", topicId: "4.3", readingTime: "7 min read", difficulty: "Medium", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Object-Oriented Programming" }), " promises flexibility, and ", _jsx(_components.strong, { children: "Polymorphism" }), " is the crown jewel that delivers on this promise. At its core, polymorphism means \"many forms\" — the ability of a single interface (a function, an operator, or an object) to behave in multiple ways based on the context. In C++, this is achieved through function overloading, operator overloading, and virtual functions."] }), _jsxs(_components.p, { children: ["In this subtopic, we will establish a rock-solid foundation for understanding what polymorphism is, why it is indispensable in extensible system design, and how C++ implements its two fundamental types: ", _jsx(_components.strong, { children: "Compile-Time Polymorphism" }), " and ", _jsx(_components.strong, { children: "Run-Time Polymorphism" }), "."] }), _jsxs(Intuition, { title: "The Universal Remote Control", children: [_jsxs(_components.p, { children: ["💡 Think of a universal remote control. It has one ", _jsx(_components.code, { children: "Power" }), " button."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["When you point it at a ", _jsx(_components.strong, { children: "TV" }), ", the ", _jsx(_components.code, { children: "Power" }), " button turns the TV on/off."] }), "\n", _jsxs(_components.li, { children: ["When you point it at a ", _jsx(_components.strong, { children: "Speaker" }), ", the same ", _jsx(_components.code, { children: "Power" }), " button switches the speaker on/off."] }), "\n", _jsxs(_components.li, { children: ["When you point it at an ", _jsx(_components.strong, { children: "Air Conditioner" }), ", it powers the AC on/off.\n", _jsx(_components.strong, { children: "The interface (the button) is the same, but the implementation (what happens) is different depending on the object it is acting upon." }), "\nThis is the essence of Polymorphism: ", _jsx(_components.strong, { children: "\"One interface, multiple methods.\"" })] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Concept of Polymorphism:" }), " One interface, multiple forms, and its role in OOP."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compile-Time Polymorphism:" }), " Mechanism via function and operator overloading (Static/Early Binding)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Run-Time Polymorphism:" }), " Mechanism via virtual functions (Dynamic/Late Binding)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Binding:" }), " Understanding the difference between static (early) and dynamic (late) binding."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Object-Oriented Programming" }), " flexibility ka vaada karti hai, aur ", _jsx(_components.strong, { children: "Polymorphism" }), " woh crown jewel hai jo is vaade ko poora karta hai. Iske core mein, polymorphism ka matlab hai \"many forms\" — kisi bhi single interface (function, operator, ya object) ki capacity ki woh multiple contexts mein multiple behaviors dikha sake. C++ mein, yeh function overloading, operator overloading, aur virtual functions ke madhyam se achieve kiya jata hai."] }), _jsxs(_components.p, { children: ["Is subtopic mein, hum ek rock-solid foundation banayenge ki polymorphism kya hota hai, extensible system design mein yeh kyun indispensable hai, aur C++ iske do fundamental types ko kaise implement karta hai: ", _jsx(_components.strong, { children: "Compile-Time Polymorphism" }), " aur ", _jsx(_components.strong, { children: "Run-Time Polymorphism" }), "."] }), _jsxs(Intuition, { title: "The Universal Remote Control", children: [_jsxs(_components.p, { children: ["💡 Aap ek universal remote control ke baare mein sochiye. Is par ek ", _jsx(_components.code, { children: "Power" }), " button hota hai."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Jab aap ise ", _jsx(_components.strong, { children: "TV" }), " ki taraf point karte hain, toh ", _jsx(_components.code, { children: "Power" }), " button TV ko on/off karta hai."] }), "\n", _jsxs(_components.li, { children: ["Jab aap ise ", _jsx(_components.strong, { children: "Speaker" }), " ki taraf point karte hain, toh wohi button speaker ko on/off karta hai."] }), "\n", _jsxs(_components.li, { children: ["Jab aap ise ", _jsx(_components.strong, { children: "Air Conditioner" }), " ki taraf point karte hain, toh yeh AC ko on/off karta hai.\n", _jsx(_components.strong, { children: "Interface (button) ek jaisa hai, lekin implementation (hota kya hai) alag-alag objects ke saath badal jaata hai." }), "\nYeh hai Polymorphism ka essence: ", _jsx(_components.strong, { children: "\"One interface, multiple methods.\"" })] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Concept of Polymorphism:" }), " One interface, multiple forms, aur OOP mein iski bhoomika."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compile-Time Polymorphism:" }), " Function aur operator overloading ke through mechanism (Static/Early Binding)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Run-Time Polymorphism:" }), " Virtual functions ke through mechanism (Dynamic/Late Binding)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Binding:" }), " Static (early) aur dynamic (late) binding ke beech ka antar samajhna."] }), "\n"] })] })] }), "\n", _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Polymorphism", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["In Object-Oriented Programming, ", _jsx(_components.strong, { children: "Polymorphism" }), " is the ability of a single function, operator, or object to behave in multiple forms based on the context in which it is used."] }), _jsx(Intuition, { title: "Ek Vyakti, Kai Roop (One Person, Many Roles)", children: _jsx(_components.p, { children: "💡 Think of a man in his daily life. He acts as a Father to his children, an Employee to his boss, and a Customer at a store. The entity (the man) is the same, but the behavior (function) adapts according to the situation. This is the real-world soul of Polymorphism." }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["Object-Oriented Programming mein, ", _jsx(_components.strong, { children: "Polymorphism" }), " kisi single function, operator, ya object ki capacity hoti hai ki woh multiple forms mein behave kare context ke hisaab se."] }), _jsx(Intuition, { title: "Ek Vyakti, Kai Roop (One Person, Many Roles)", children: _jsx(_components.p, { children: "💡 Ek aadmi ko dekhiye. Woh apne bachchon ke liye Pita hai, apne boss ke liye Employee hai, aur market mein Customer hai. Entity (woh aadmi) ek hai, lekin behavior (function) situation ke hisaab se badalta hai. Yeh hai Polymorphism ki aatma." }) })] })] }), _jsxs(DefinitionEntry, { term: "Compile Time Polymorphism (Static Polymorphism)", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Compile Time Polymorphism" }), " is a type of Polymorphism where the compiler determines which function or operator to call by examining the function signature (number and type of arguments) or operators used, and this decision is made before the program runs."] }), _jsx(Intuition, { title: "The Vending Machine", children: _jsxs(_components.p, { children: ["💡 Imagine a vending machine. You press a button (interface) corresponding to a snack code (arguments). The machine instantly knows exactly which snack to drop and drops it ", _jsx(_components.em, { children: "immediately" }), " without any delay. The decision is made at the \"compile time\" of the press — early and efficient."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Compile Time Polymorphism" }), " woh polymorphism hai jisme compiler program ke run hone se pehle hi decide kar leta hai ki kaunsa function ya operator call hoga. Yeh decision function ke signature (arguments ki sankhya aur type) ya operators ke aadhar par hota hai."] }), _jsx(Intuition, { title: "The Vending Machine", children: _jsxs(_components.p, { children: ["💡 Ek vending machine ko dekhiye. Aap snack code ke corresponding button (interface) dabate hain (arguments). Machine turant jaanta hai ki kaunsa snack dena hai aur bina kisi delay ke ", _jsx(_components.em, { children: "turant" }), " woh snack de deta hai. Decision press ke \"compile time\" par ho jata hai — jaldi aur efficient."] }) })] })] }), _jsxs(DefinitionEntry, { term: "Run Time Polymorphism (Dynamic Polymorphism)", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Run Time Polymorphism" }), " is a type of Polymorphism where the function to be executed is decided only when the program is running. It is typically achieved using virtual functions and base class pointers or references."] }), _jsx(Intuition, { title: "The GPS Navigation", children: _jsxs(_components.p, { children: ["💡 Imagine you are driving. You tell your phone's GPS \"Navigate to the Airport\". The GPS does not know the exact final route until it starts calculating based on real-time traffic ", _jsx(_components.em, { children: "while you are driving" }), ". The exact path (function) is dynamically determined at \"run time\"."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Run Time Polymorphism" }), " woh polymorphism hai jisme function ka execution decision program ke run hone ke dauran liya jata hai. Yeh aam taur par virtual functions aur base class pointers ya references ke madhyam se achieve kiya jata hai."] }), _jsx(Intuition, { title: "The GPS Navigation", children: _jsxs(_components.p, { children: ["💡 Aap gaadi chala rahe hain. Aap phone ke GPS ko kehte hain \"Airport chalo\". GPS ko tab tak exact final route nahi pata hota jab tak woh real-time traffic ke aadhar par ", _jsx(_components.em, { children: "gaadi chalane ke dauran" }), " calculate karna shuru na kare. Exact path (function) dynamically \"run time\" par determine hota hai."] }) })] })] })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "The Core Mechanism: Binding" }), _jsxs(_components.p, { children: ["To truly understand the difference between the two types of polymorphism, we must first understand the concept of ", _jsx(_components.strong, { children: "Binding" }), "."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "🤔 Kya aap jaante hain ki compiler ya runtime kaise decide karte hain ki kaunsa function execute hoga?" }) }), _jsx(_components.p, { children: "Binding is the process of linking a function call (identifier) to its actual definition in memory." }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Early Binding (Static Binding):" }), " The compiler knows exactly which function to call at compile time itself. This is used for normal functions, overloaded functions, and overloaded operators."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Late Binding (Dynamic Binding):" }), " The compiler does not know which function to call until the program runs. This is used for virtual functions. The decision is made based on the actual type of the object stored in memory."] }), "\n"] }), _jsx(_components.h3, { children: "Diving into the Two Types" }), _jsx(_components.p, { children: "Let us now explore the two pillars of polymorphism in detail." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "The Core Mechanism: Binding" }), _jsxs(_components.p, { children: ["Do prakar ke polymorphism ke beech ka antar samajhne ke liye, pehle ", _jsx(_components.strong, { children: "Binding" }), " ke concept ko samajhna zaroori hai."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "🤔 Kya aap jaante hain ki compiler ya runtime kaise decide karte hain ki kaunsa function execute hoga?" }) }), _jsx(_components.p, { children: "Binding, function call (identifier) ko uski actual memory definition se jodne ki process hai." }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Early Binding (Static Binding):" }), " Compiler ko compile time par hi pata hota hai ki kaunsa function call karna hai. Yeh normal functions, overloaded functions, aur overloaded operators ke liye use hota hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Late Binding (Dynamic Binding):" }), " Compiler ko nahi pata hota ki kaunsa function call karna hai jab tak program run na kare. Yeh virtual functions ke liye use hota hai. Decision memory mein store actual object ke type ke aadhar par hota hai."] }), "\n"] }), _jsx(_components.h3, { children: "Diving into the Two Types" }), _jsx(_components.p, { children: "Chaliye polymorphism ke in do stambhon ko detail mein samajhte hain." })] }), _jsx(ComparisonTable, { title: "Compile-Time vs Run-Time Polymorphism", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Feature" }), _jsx(_components.th, { children: "Compile-Time Polymorphism" }), _jsx(_components.th, { children: "Run-Time Polymorphism" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Also Known As" }) }), _jsx(_components.td, { children: "Static Polymorphism / Early Binding" }), _jsx(_components.td, { children: "Dynamic Polymorphism / Late Binding" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Achieved By" }) }), _jsx(_components.td, { children: "Function Overloading, Operator Overloading" }), _jsx(_components.td, { children: "Virtual Functions, Base Class Pointers/References" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "When Resolved" }) }), _jsx(_components.td, { children: "At Compile Time" }), _jsx(_components.td, { children: "At Run Time" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Execution Speed" }) }), _jsx(_components.td, { children: "Faster (No runtime overhead for decision making)" }), _jsx(_components.td, { children: "Slightly Slower (Requires vtable lookup at runtime)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Flexibility" }) }), _jsx(_components.td, { children: "Less Flexible (Function signature must match exactly at compile time)" }), _jsx(_components.td, { children: "Highly Flexible (Object type is determined dynamically)" })] })] })] }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\n P[Polymorphism] --> CP[Compile-Time Polymorphism
Static / Early Binding]\n P --> RP[Run-Time Polymorphism
Dynamic / Late Binding]\n CP --> FO[Function Overloading]\n CP --> OO[Operator Overloading]\n RP --> VF[Virtual Functions]\n RP --> PVF[Pure Virtual Functions / Abstract Classes]\n" }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "Visualizing The Difference With Code" }), _jsx(_components.p, { children: "Let's see a quick code example that demonstrates both types. Notice how the decision-making process differs." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Visualizing The Difference With Code" }), _jsx(_components.p, { children: "Aaiye ek quick code example dekhte hain jo dono prakar ko demonstrate karta hai. Dhyan dijiye ki decision-making process kaise alag hai." })] }), _jsx(CodeBlock, { language: "cpp", children: `#include using namespace std; // ---- Compile-Time Polymorphism: Function Overloading ---- // The compiler decides which 'print' to call based on the argument type. void print(int i) { cout << "Integer: " << i << endl; } void print(double f) { cout << "Double: " << f << endl; } // ---- Run-Time Polymorphism: Virtual Functions ---- // The program decides which 'sound' to call based on the actual object type. class Vehicle { public: virtual void sound() { cout << "Vehicle makes a generic sound" << endl; } }; class Car : public Vehicle { public: void sound() override { cout << "Car goes Vroom Vroom" << endl; } }; int main() { // Compile-Time Binding cout << "--- Compile Time ---" << endl; print(5); // Compiler selects print(int) print(3.14); // Compiler selects print(double) // Run-Time Binding cout << "--- Run Time ---" << endl; Vehicle* v = new Car(); // Base class pointer pointing to Derived object v->sound(); // At runtime, the program checks the vtable and calls Car::sound() delete v; return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "Why Is This Crucial for Software Design?" }), _jsxs(_components.p, { children: ["Polymorphism allows us to write ", _jsx(_components.strong, { children: "generic and extensible code" }), ". You can write functions that take a base class pointer and call virtual functions on it. If a new derived class is added later, the same code works ", _jsx(_components.em, { children: "without any modification" }), ". This is the \"Open for extension, closed for modification\" principle in action."] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Polymorphism embodies the ", _jsx(_components.strong, { children: "\"One interface, multiple methods\"" }), " philosophy, reusing standard interfaces."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compile-time polymorphism" }), " is resolved during compilation, offering maximum speed through ", _jsx(_components.strong, { children: "early binding" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Run-time polymorphism" }), " is resolved during execution, offering maximum flexibility through ", _jsx(_components.strong, { children: "late binding" }), "."] }), "\n", _jsx(_components.li, { children: "Mastering this distinction is mandatory before exploring advanced topics like operator overloading and pure virtual functions in subsequent subtopics." }), "\n"] }) }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Why Is This Crucial for Software Design?" }), _jsxs(_components.p, { children: ["Polymorphism humein ", _jsx(_components.strong, { children: "generic aur extensible code" }), " likhne ki anumati deta hai. Aap aise functions likh sakte hain jo base class pointer le aur us par virtual function call kare. Agar baad mein koi naya derived class add hota hai, toh wohi code ", _jsx(_components.em, { children: "bina kisi modification ke" }), " kaam karega. Yeh \"Open for extension, closed for modification\" principle ka practical example hai."] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Polymorphism ", _jsx(_components.strong, { children: "\"One interface, multiple methods\"" }), " philosophy ko represent karta hai, standard interfaces ko reuse karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compile-time polymorphism" }), " compilation ke dauran resolve hota hai, ", _jsx(_components.strong, { children: "early binding" }), " ke madhyam se maximum speed provide karta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Run-time polymorphism" }), " execution ke dauran resolve hota hai, ", _jsx(_components.strong, { children: "late binding" }), " ke madhyam se maximum flexibility provide karta hai."] }), "\n", _jsx(_components.li, { children: "Ye antar samajhna aane wale subtopics (operator overloading, pure virtual functions) ko master karne ke liye zaroori hai." }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Define polymorphism and list its types in C++.", "marks": 2, "a": { "components": [{ "type": "Explanation", "content": "**Polymorphism** is a core concept of OOP that allows objects of different classes to be treated as objects of a common base class. The term means 'many forms' — a single function or operator can behave differently based on the context.\n\n In C++, polymorphism is mainly classified into:\n\n - **Compile‑time Polymorphism** (also called static binding or early binding)\n - **Run‑time Polymorphism** (also called dynamic binding or late binding)" }] } }, { "q": "Differentiate between compile-time polymorphism and run-time polymorphism in C++.", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "| Aspect | Compile‑time Polymorphism | Run‑time Polymorphism |\n |---|---|---|\n | **Achieved by** | Function overloading, Operator overloading | Virtual functions |\n | **Binding time** | During compilation | During program execution |\n | **Speed** | Faster (resolution done at compile time) | Slightly slower (resolution at run time) |\n | **Function call** | Resolved based on the number/types of arguments | Resolved based on the actual object type (using vtable) |\n | **Flexibility** | Less flexible – exact function known at compile time | More flexible – allows dynamic behavior |\n \n\n \n Compile‑time polymorphism is used when the same operation should behave differently based on argument counts or types. Run‑time polymorphism is essential when you want base‑class pointers to call derived‑class overridden methods." }] } }, { "q": "Explain the types of polymorphism in C++ with suitable code examples.", "marks": 6, "a": { "components": [{ "type": "Explanation", "content": "### 💡 1. Compile‑time Polymorphism\n\n Also called **static polymorphism**. The compiler decides which function to call at compile time. It is achieved through:\n\n - **Function overloading** – multiple functions with the same name but different parameters.\n - **Operator overloading** – customizing operators for user‑defined types.\n\n **Example – Function overloading:**\n\n \n {`#include \n using namespace std;\n\n class Display {\n public:\n void show(int i) {\n cout << \"Integer: \" << i << endl;\n }\n void show(double d) {\n cout << \"Double: \" << d << endl;\n }\n };\n\n int main() {\n Display obj;\n obj.show(10); // calls show(int)\n obj.show(3.14); // calls show(double)\n return 0;\n }`}\n \n\n **Output:**\n ```\n Integer: 10\n Double: 3.14\n ```\n\n ### 🧠 2. Run‑time Polymorphism\n\n Also called **dynamic polymorphism**. The function to be called is decided at run time. It is achieved through **virtual functions** and **inheritance**.\n\n **Example – Virtual function:**\n\n \n {`#include \n using namespace std;\n\n class Base {\n public:\n virtual void display() {\n cout << \"Base class display\" << endl;\n }\n };\n\n class Derived : public Base {\n public:\n void display() override {\n cout << \"Derived class display\" << endl;\n }\n };\n\n int main() {\n Base* ptr;\n Derived obj;\n ptr = &obj;\n ptr->display(); // run‑time: calls Derived::display()\n return 0;\n }`}\n \n\n **Output:**\n ```\n Derived class display\n ```\n\n \n - For run‑time polymorphism, the base class function must be declared **virtual**.\n - The function call is resolved using the **vtable** (virtual table) at run time.\n - Without the `virtual` keyword, only the base class version would be called (compile‑time binding)." }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "c331de75-b5a5-4a24-8885-8fa00fa7ed4f", "q": "What does the term 'polymorphism' mean in Object-Oriented Programming?", "options": ["Many forms", "One form", "No form", "Same form"], "answer": 0, "hint": "Think about Greek origin of term.", "explanation": "Polymorphism means the ability to have many forms." }, { "id": "952c1f8e-3b06-4c78-8632-768ef4029ead", "q": "Which of the following correctly represents the classification of polymorphism in C++?", "options": ["Compile-time polymorphism", "Runtime polymorphism", "Both compile-time and runtime polymorphism", "None of the above"], "answer": 2, "hint": "Polymorphism is categorized based on when the function call is resolved.", "explanation": "Polymorphism is classified into compile-time (static) and runtime (dynamic) polymorphism." }, { "id": "cea11e16-3900-4d9d-bdea-71b9166e954a", "q": "Which of the following is an example of compile-time polymorphism?", "options": ["Virtual functions", "Function overloading", "Abstract class", "Pure virtual function"], "answer": 1, "hint": "This feature decides which function to call at compile time.", "explanation": "Function overloading is an example of compile-time polymorphism as it is resolved during compilation." }, { "id": "edb86644-d62b-4ac9-8d0f-7c0eb87cc2b6", "q": "Which of the following is used to achieve runtime polymorphism in C++?", "options": ["Virtual functions", "Function overloading", "Operator overloading", "Inline functions"], "answer": 0, "hint": "Virtual functions allow late binding.", "explanation": "Runtime polymorphism in C++ is achieved using virtual functions." }, { "id": "6819e193-28ab-47c8-889c-34bfcf21c836", "q": "What does the prefix 'poly' in the word 'polymorphism' signify?", "options": ["Many", "One", "Same", "Different"], "answer": 0, "hint": "'Poly' is Greek for many.", "explanation": "The word 'poly' means many and 'morph' means form." }, { "id": "06d178a7-d47d-4ccd-9f18-b0b3a6f130ad", "q": "Which type of polymorphism is also known as dynamic polymorphism?", "options": ["Compile-time polymorphism", "Runtime polymorphism", "Ad-hoc polymorphism", "Parametric polymorphism"], "answer": 1, "hint": "This type of polymorphism is resolved after program execution starts.", "explanation": "Runtime polymorphism is also called dynamic polymorphism because it is resolved at runtime." }, { "id": "39f69a24-3250-49bc-8850-2dc3249600be", "q": "Which binding is associated with compile-time polymorphism?", "options": ["Late binding", "Dynamic binding", "Early binding", "Run-time binding"], "answer": 2, "hint": "Early binding happens at compile time.", "explanation": "Compile-time polymorphism uses early binding, where the function call is resolved before execution." }, { "id": "c4e34137-5d2f-40de-ba6d-749b97693afb", "q": "Which of the following is NOT a type of polymorphism in C++?", "options": ["Overloading", "Overriding", "Encapsulation", "Inclusion"], "answer": 2, "hint": "This is not a form of polymorphism.", "explanation": "Encapsulation is a different OOP concept and not a type of polymorphism." }, { "id": "0a251518-241b-4ed6-af05-6a5bd1c0555b", "q": "Polymorphism is implemented in C++ through which of the following mechanisms?", "options": ["Only inheritance", "Only overloading", "Overloading and overriding", "Only overriding"], "answer": 2, "hint": "Consider how function overloading and virtual functions contribute.", "explanation": "Both function overloading (compile-time) and virtual functions (runtime) are mechanisms of polymorphism." }, { "id": "fbd013e1-8318-4743-95b6-8808b1cbd239", "q": "What is the ability of a function to behave differently based on the object that calls it called?", "options": ["Polymorphism", "Inheritance", "Encapsulation", "Abstraction"], "answer": 0, "hint": "The ability to take many forms is the basic definition.", "explanation": "Polymorphism allows functions to have different behaviors based on the object or context." }], topicId: "4.3" })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }