"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", ul: "ul", ..._provideComponents(), ...props.components }, {CodeBlock, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, Intuition, KeyPoints, Note, SubTopicHeader, TopicOverview} = _components; if (!CodeBlock) _missingMdxReference("CodeBlock", 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 (!Intuition) _missingMdxReference("Intuition", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!Note) _missingMdxReference("Note", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "4.5", title: "Run Time Polymorphism: Virtual Functions, Rules for Virtual Functions, Pure Virtual Functions" }), "\n", _jsxs(TopicOverview, { title: "Introduction to Run Time Polymorphism", topicId: "4.5", readingTime: "8 min read", difficulty: "Hard", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Run‑time polymorphism" }), " is a cornerstone feature of C++ that enables a function call to be resolved at run‑time based on the actual type of the object, rather than on the type of the pointer or reference. This mechanism — implemented through ", _jsx(_components.strong, { children: "virtual functions" }), " — allows base‑class pointers to seamlessly invoke derived‑class overrides, forming the backbone of dynamic binding and flexible object‑oriented design."] }), _jsx(_components.p, { children: "In this subtopic we will examine how virtual functions work, the rules that govern their use, and the concept of pure virtual functions that lead to abstract classes." }), _jsx(Intuition, { title: "Universal Remote Analogy", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Real‑world parallel" }), " – A universal remote has a “Play” button. Pressing it on a DVD player starts a movie; on a music system, it plays a song. The same button invokes different behaviour depending on the actual device connected. Similarly, a base‑class pointer to a virtual function asks, “What is the actual object type at run‑time?” and calls the appropriate override."] }) }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Understand ", _jsx(_components.strong, { children: "run‑time polymorphism" }), " and how it differs from compile‑time polymorphism."] }), "\n", _jsxs(_components.li, { children: ["Define a ", _jsx(_components.strong, { children: "virtual function" }), " and explain the ", _jsx(_components.strong, { children: "late binding" }), " (vtable) mechanism."] }), "\n", _jsxs(_components.li, { children: ["Memorise the ", _jsx(_components.strong, { children: "rules for virtual functions" }), " (static, friend, constructor restrictions, signature matching, etc.)."] }), "\n", _jsxs(_components.li, { children: ["Recognise ", _jsx(_components.strong, { children: "pure virtual functions" }), " and how they create ", _jsx(_components.strong, { children: "abstract classes" }), "."] }), "\n", _jsx(_components.li, { children: "Be able to write and trace code that uses virtual and pure virtual functions." }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Run‑time polymorphism" }), " C++ ka ek aham feature hai jo function call ko run‑time par actual object ke type ke aadhar par resolve karta hai, na ki pointer ya reference ke type ke aadhar par. Yeh mechanism — ", _jsx(_components.strong, { children: "virtual functions" }), " ke madhyam se implement hota hai — jisse base‑class pointers derived‑class overrides ko seamlessly call kar sakte hain, jo dynamic binding aur flexible object‑oriented design ki foundation hai."] }), _jsx(_components.p, { children: "Is subtopic mein hum samjhenge ki virtual functions kaise kaam karti hain, unke upyog ke niyam kya hain, aur pure virtual functions ka concept jo abstract classes ko janam deta hai." }), _jsx(Intuition, { title: "Universal Remote Analogy", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Real‑world parallel" }), " – Universal remote mein “Play” button hota hai. DVD player par dabane se movie chalti hai; music system par dabane se gaana bajta hai. Ek hi button actual device ke hisaab se alag behavior produce karta hai. Isi tarah, base‑class pointer se virtual function call par puchha jaata hai, “Actual object type run‑time par kya hai?” aur appropriate override call hota hai."] }) }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Run‑time polymorphism" }), " ko samajhna aur ise compile‑time polymorphism se compare karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Virtual function" }), " ko define karna aur ", _jsx(_components.strong, { children: "late binding" }), " (vtable) mechanism ko samajhna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Virtual functions ke niyam" }), " (static, friend, constructor restrictions, signature matching, etc.) ko yaad karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Pure virtual functions" }), " aur unse bane ", _jsx(_components.strong, { children: "abstract classes" }), " ko pehchanna."] }), "\n", _jsx(_components.li, { children: "Virtual aur pure virtual functions ka upyog karte code likhne aur trace karne mein skilled hona." }), "\n"] })] })] }), "\n", _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Virtual Function", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "virtual function" }), " is a member function declared in a base class with the ", _jsx(_components.code, { children: "virtual" }), " keyword. It can be overridden in derived classes, and when called through a base‑class pointer or reference, the actual function executed is determined at run‑time based on the object type."] }), _jsx(Intuition, { title: "Job Description Analogy", children: _jsxs(_components.p, { children: ["💡 Think of a virtual function like a ", _jsx(_components.strong, { children: "job description" }), " written in a company handbook (base class). Different employees (derived classes) perform that same job in their own way. For example, “calculate bonus” is defined generally, but a manager might calculate it differently than a salesperson. The company just says “calculate bonus” (the virtual function), and each employee does it their own way."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Virtual function" }), " woh member function hoti hai jise base class mein ", _jsx(_components.code, { children: "virtual" }), " keyword se declare kiya jaata hai. Derived classes use override kar sakti hain, aur jab base‑class pointer ya reference ke through call kiya jaaye, to actual function run‑time par object ke type ke aadhar par decide hota hai."] }), _jsx(Intuition, { title: "Job Description Analogy", children: _jsxs(_components.p, { children: ["💡 Virtual function ko aap ", _jsx(_components.strong, { children: "company handbook mein likhi job description" }), " ki tarah samajh sakte hain. Different employees (derived classes) us job description ko apne tarike se perform karte hain. Jaise “calculate bonus” ka task generally defined hai, lekin manager usse alag calculate karega aur salesperson alag."] }) })] })] }), _jsxs(DefinitionEntry, { term: "Rules for Virtual Functions", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "rules for virtual functions" }), " are the set of constraints that must be followed when declaring and using virtual functions in C++ to ensure correct polymorphic behaviour."] }), _jsx(Intuition, { title: "Traffic Rules Analogy", children: _jsx(_components.p, { children: "🚦 Just as traffic rules keep vehicles moving safely, virtual function rules keep polymorphism working correctly. For instance, a virtual function cannot be a constructor (a car cannot fly), and its signature must match in derived classes (lane discipline). Breaking these rules leads to compiler errors or unintended behaviour." }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Virtual functions ke niyam" }), " woh constraints ka set hai jo C++ mein virtual functions declare aur use karte waqt follow karne zaroori hain, jisse sahi polymorphic behaviour mile."] }), _jsx(Intuition, { title: "Traffic Rules Analogy", children: _jsx(_components.p, { children: "🚦 Jis tarah traffic rules vehicles ko safe chalate hain, usi tarah virtual function rules polymorphism ko sahi se kaam karte hain. Jaise virtual function constructor nahi ho sakta (car ud nahi sakti), aur derived class mein signature match hona chahiye (lane discipline). In niyamon ko todne se compiler errors ya galat behaviour hota hai." }) })] })] }), _jsxs(DefinitionEntry, { term: "Pure Virtual Function", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "pure virtual function" }), " is a virtual function declared by assigning ", _jsx(_components.code, { children: "= 0" }), " in the base class. It has no body in the base class and makes that class ", _jsx(_components.strong, { children: "abstract" }), " — derived classes must provide their own implementation, or they remain abstract as well."] }), _jsx(Intuition, { title: "Contract Clause Analogy", children: _jsxs(_components.p, { children: ["📜 Think of a pure virtual function as a clause in a contract that says “This service ", _jsx(_components.strong, { children: "must" }), " be provided”, but doesn’t specify how. Each derived class (contractor) must implement that service in its own way. Without an implementation, the contract is incomplete (the class is abstract)."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Pure virtual function" }), " woh virtual function hota hai jise base class mein ", _jsx(_components.code, { children: "= 0" }), " assign karke declare kiya jaata hai. Base class mein iska koi body nahi hota aur woh class ", _jsx(_components.strong, { children: "abstract" }), " ban jaati hai — derived classes ko apna implementation dena hota hai, warna woh bhi abstract rehti hain."] }), _jsx(Intuition, { title: "Contract Clause Analogy", children: _jsxs(_components.p, { children: ["📜 Pure virtual function ko aap ek contract ke clause ki tarah samajh sakte hain jo kahe ki “Yeh seva ", _jsx(_components.strong, { children: "avashya" }), " pradaan karni hogi”, lekin yeh nahi batata ki kaise. Har derived class (contractor) use apne tarike se implement karti hai. Agar implementation nahi di, to contract adhoora hai (class abstract hai)."] }) })] })] })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "1. What is Run‑time Polymorphism?" }), _jsxs(_components.p, { children: ["In object‑oriented programming, ", _jsx(_components.strong, { children: "polymorphism" }), " allows a single function call to exhibit different behaviours depending on the context. ", _jsx(_components.strong, { children: "Compile‑time polymorphism" }), " (function/operator overloading) is resolved early, while ", _jsx(_components.strong, { children: "run‑time polymorphism" }), " is resolved at the moment the call actually happens."] }), _jsxs(_components.p, { children: ["Run‑time polymorphism in C++ is achieved through ", _jsx(_components.strong, { children: "virtual functions" }), ". A virtual function declared in a base class can be overridden in derived classes. When you call that function using a ", _jsx(_components.strong, { children: "base‑class pointer" }), " or ", _jsx(_components.strong, { children: "reference" }), " that points to a derived object, the compiler inserts code to look up the correct override ", _jsx(_components.strong, { children: "at run‑time" }), " based on the actual object type. This is called ", _jsx(_components.strong, { children: "dynamic binding" }), " or ", _jsx(_components.strong, { children: "late binding" }), "."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "1. Run‑time Polymorphism Kya Hai?" }), _jsxs(_components.p, { children: ["Object‑oriented programming mein ", _jsx(_components.strong, { children: "polymorphism" }), " ka matlab hai ki ek hi function call alag‑alag contexts mein alag behaviour dikha sake. ", _jsx(_components.strong, { children: "Compile‑time polymorphism" }), " (function/operator overloading) early resolve hota hai, jabki ", _jsx(_components.strong, { children: "run‑time polymorphism" }), " call hone ke waqt resolve hota hai."] }), _jsxs(_components.p, { children: ["C++ mein run‑time polymorphism ", _jsx(_components.strong, { children: "virtual functions" }), " ke madhyam se achieve hota hai. Base class mein declare kiya gaya virtual function derived classes mein override kiya ja sakta hai. Jab aap us function ko ", _jsx(_components.strong, { children: "base‑class pointer" }), " ya ", _jsx(_components.strong, { children: "reference" }), " se call karte hain jo kisi derived object ko point kar raha ho, to compiler run‑time par actual object type ke hisaab se sahi override ko call karne ka code daalta hai. Is process ko ", _jsx(_components.strong, { children: "dynamic binding" }), " ya ", _jsx(_components.strong, { children: "late binding" }), " kehte hain."] })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "2. Virtual Function and Late Binding" }), _jsxs(_components.p, { children: ["Consider a base class ", _jsx(_components.code, { children: "Base" }), " with a virtual function ", _jsx(_components.code, { children: "show()" }), ", and a derived class ", _jsx(_components.code, { children: "Derived" }), " that overrides ", _jsx(_components.code, { children: "show()" }), ". When we create a ", _jsx(_components.code, { children: "Base*" }), " pointer pointing to a ", _jsx(_components.code, { children: "Derived" }), " object and call ", _jsx(_components.code, { children: "show()" }), ", the call is not resolved at compile time — instead, the compiler sets up a ", _jsx(_components.strong, { children: "virtual table (vtable)" }), " mechanism."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "How it works:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Every class that contains (or inherits) virtual functions has a static ", _jsx(_components.strong, { children: "vtable" }), " — an array of function pointers pointing to the most‑derived overrides."] }), "\n", _jsxs(_components.li, { children: ["Each object of such a class contains a hidden pointer ", _jsx(_components.strong, { children: "vptr" }), ", which points to the vtable of its own class."] }), "\n", _jsx(_components.li, { children: "During a virtual function call, the code follows the vptr → vtable → function pointer chain to invoke the correct version." }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "2. Virtual Function aur Late Binding" }), _jsxs(_components.p, { children: ["Maan lijiye ek base class ", _jsx(_components.code, { children: "Base" }), " hai jismein ek virtual function ", _jsx(_components.code, { children: "show()" }), " hai, aur ek derived class ", _jsx(_components.code, { children: "Derived" }), " hai jo ", _jsx(_components.code, { children: "show()" }), " ko override karti hai. Jab hum ek ", _jsx(_components.code, { children: "Base*" }), " pointer banate hain jo ", _jsx(_components.code, { children: "Derived" }), " object ko point karta hai, aur ", _jsx(_components.code, { children: "show()" }), " call karte hain, to call compile time par resolve nahi hota — balki compiler ek ", _jsx(_components.strong, { children: "virtual table (vtable)" }), " mechanism tayyar karta hai."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Kaise kaam karta hai:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Har class jismein virtual functions hote hain (ya inherit hote hain) ke paas ek static ", _jsx(_components.strong, { children: "vtable" }), " hoti hai — function pointers ki array, jo sabse derived override ko point karti hai."] }), "\n", _jsxs(_components.li, { children: ["Aisi class ke har object mein ek hidden pointer ", _jsx(_components.strong, { children: "vptr" }), " hota hai, jo apni class ke vtable ko point karta hai."] }), "\n", _jsx(_components.li, { children: "Virtual function call ke waqt, code vptr → vtable → function pointer chain follow karta hai aur sahi version ko invoke karta hai." }), "\n"] })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart LR\n subgraph Base\n B_vtable[\"vtable for Base\"]\n B_vptr(\"vptr (points to Base vtable)\")\n B_vtable --> BF[\"virtual void show() → Base::show()\"]\n end\n subgraph Derived\n D_vtable[\"vtable for Derived\"]\n D_vptr(\"vptr (points to Derived vtable)\")\n D_vtable --> DF[\"virtual void show() → Derived::show()\"]\n end\n" }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "3. Rules for Virtual Functions" }), _jsx(_components.p, { children: "When using virtual functions, the following rules must be observed to avoid errors and ensure predictable behaviour:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["A virtual function ", _jsx(_components.strong, { children: "must be a non‑static member" }), " of a class."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Friend functions" }), " and ", _jsx(_components.strong, { children: "constructors" }), " cannot be virtual."] }), "\n", _jsxs(_components.li, { children: ["A destructor can be virtual (", _jsx(_components.strong, { children: "virtual destructor" }), ") — this is essential when deleting objects through base‑class pointers."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "prototype" }), " (name, parameter list, and return type) of the virtual function must be ", _jsx(_components.strong, { children: "identical" }), " in the base and derived classes (exception: ", _jsx(_components.strong, { children: "covariant return types" }), " are allowed)."] }), "\n", _jsxs(_components.li, { children: ["Once a function is declared virtual in a base class, it remains virtual in all derived classes even if the ", _jsx(_components.code, { children: "virtual" }), " keyword is not repeated."] }), "\n", _jsxs(_components.li, { children: ["A virtual function can be called ", _jsx(_components.strong, { children: "non‑polymorphically" }), " by using the class name and scope resolution operator (", _jsx(_components.code, { children: "Base::show()" }), ")."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "3. Virtual Functions ke Niyam" }), _jsx(_components.p, { children: "Virtual functions ka upyog karte waqt in niyamon ko dhyaan mein rakhna chahiye:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Virtual function ", _jsx(_components.strong, { children: "class ka ek non‑static member" }), " hona chahiye."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Friend functions" }), " aur ", _jsx(_components.strong, { children: "constructors" }), " virtual nahi ho sakte."] }), "\n", _jsxs(_components.li, { children: ["Destructor virtual ho sakta hai (", _jsx(_components.strong, { children: "virtual destructor" }), ") — yeh tab zaroori hai jab base‑class pointer ke through objects delete kiye jaayein."] }), "\n", _jsxs(_components.li, { children: ["Virtual function ka ", _jsx(_components.strong, { children: "prototype" }), " (name, parameter list, return type) base aur derived class mein ", _jsx(_components.strong, { children: "same" }), " hona chahiye (exception: ", _jsx(_components.strong, { children: "covariant return types" }), " allowed hain)."] }), "\n", _jsxs(_components.li, { children: ["Ek baar function base class mein virtual declare ho jaaye, to derived classes mein woh virtual hi rahega chahe ", _jsx(_components.code, { children: "virtual" }), " keyword dobara na likha jaaye."] }), "\n", _jsxs(_components.li, { children: ["Virtual function ", _jsx(_components.strong, { children: "non‑polymorphically" }), " bhi call kiya ja sakta hai using class name and scope resolution operator (", _jsx(_components.code, { children: "Base::show()" }), ")."] }), "\n"] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["🚫 ", _jsx(_components.strong, { children: "No static / friend / constructor" }), " can be virtual."] }), "\n", _jsxs(_components.li, { children: ["✅ ", _jsx(_components.strong, { children: "Virtual destructor" }), " is vital when deleting derived objects through base pointers."] }), "\n", _jsxs(_components.li, { children: ["📌 ", _jsx(_components.strong, { children: "Signature must match" }), " in derived class (except covariant return types)."] }), "\n", _jsxs(_components.li, { children: ["🔁 ", _jsx(_components.strong, { children: "Virtual-ness propagates" }), " automatically down the hierarchy."] }), "\n"] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "4. Pure Virtual Function and Abstract Class" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "pure virtual function" }), " is a virtual function that is declared by assigning ", _jsx(_components.code, { children: "= 0" }), " in the base class. It tells the compiler: ", _jsx(_components.em, { children: "“This function has no meaningful implementation in this class; every concrete derived class must provide its own.”" })] }), _jsxs(_components.p, { children: ["A class that contains ", _jsx(_components.strong, { children: "at least one pure virtual function" }), " becomes an ", _jsx(_components.strong, { children: "abstract class" }), ". Abstract classes:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Cannot be instantiated" }), " (you cannot create objects of them)."] }), "\n", _jsxs(_components.li, { children: ["Serve as base classes to define a ", _jsx(_components.strong, { children: "common interface" }), " for derived classes."] }), "\n", _jsx(_components.li, { children: "May contain normal (non‑virtual) member functions and even virtual functions with bodies." }), "\n"] }), _jsx(_components.p, { children: "Derived classes that do not override all pure virtual functions remain abstract and cannot be instantiated either." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "4. Pure Virtual Function aur Abstract Class" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Pure virtual function" }), " woh virtual function hota hai jise ", _jsx(_components.code, { children: "= 0" }), " assign karke declare kiya jaata hai. Yeh compiler ko bataata hai: ", _jsx(_components.em, { children: "“Is function ka class mein koi meaningful implementation nahi hai; har concrete derived class ko apna implementation dena hoga.”" })] }), _jsxs(_components.p, { children: ["Jis class mein ", _jsx(_components.strong, { children: "kam se kam ek pure virtual function" }), " ho, woh ", _jsx(_components.strong, { children: "abstract class" }), " ban jaati hai. Abstract classes:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Objects nahi banaaye ja sakte" }), " (unka instantiation possible nahi hai)."] }), "\n", _jsxs(_components.li, { children: ["Base classes ki tarah kaam karti hain, derived classes ke liye ", _jsx(_components.strong, { children: "common interface" }), " define karti hain."] }), "\n", _jsx(_components.li, { children: "Unmein normal (non‑virtual) member functions ya body ke saath virtual functions bhi ho sakte hain." }), "\n"] }), _jsx(_components.p, { children: "Jo derived classes saare pure virtual functions ko override nahi karti, woh abstract rahti hain aur unka bhi object nahi banaaya ja sakta." })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "5. Example: Virtual and Pure Virtual Functions" }), _jsx(_components.p, { children: "Let’s put everything together with a complete C++ program. We’ll create a base class with a virtual function, a derived class that overrides it, and an abstract base class with a pure virtual function to demonstrate run‑time polymorphism." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "5. Example: Virtual aur Pure Virtual Functions" }), _jsx(_components.p, { children: "Ab ek poora C++ program dekhte hain jismein hum ek virtual function, derived class override, aur pure virtual function ke saath abstract class ka upyog karenge — run‑time polymorphism ko demonstrate karne ke liye." })] }), _jsx(CodeBlock, { language: "cpp", children: `#include using namespace std; // ---------- Virtual Function Example ---------- class Animal { public: virtual void sound() { // virtual function cout << "Animal makes a sound" << endl; } virtual ~Animal() {} // virtual destructor (rule) }; class Dog : public Animal { public: void sound() override { // override cout << "Dog barks" << endl; } }; // ---------- Pure Virtual Function Example ---------- class Shape { // abstract class public: virtual void draw() = 0; // pure virtual function virtual ~Shape() {} }; class Circle : public Shape { public: void draw() override { cout << "Drawing Circle" << endl; } }; class Square : public Shape { public: void draw() override { cout << "Drawing Square" << endl; } }; int main() { // Run‑time polymorphism with virtual function Animal* animal = new Dog(); animal->sound(); // Output: Dog barks delete animal; // Run‑time polymorphism with pure virtual function Shape* shape1 = new Circle(); Shape* shape2 = new Square(); shape1->draw(); // Output: Drawing Circle shape2->draw(); // Output: Drawing Square delete shape1; delete shape2; return 0; }` }), _jsx(Note, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Note:" }), " In the ", _jsx(_components.code, { children: "Animal" }), " example, without the ", _jsx(_components.code, { children: "virtual" }), " keyword, ", _jsx(_components.code, { children: "animal->sound()" }), " would call ", _jsx(_components.code, { children: "Animal::sound()" }), " even if the object is a ", _jsx(_components.code, { children: "Dog" }), " — that would be compile‑time binding. With ", _jsx(_components.code, { children: "virtual" }), ", the ", _jsx(_components.strong, { children: "actual object type" }), " determines the call, which is run‑time polymorphism."] }) })] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { children: "\ndraw(); // Calls Circle's draw\\n\\n ptr = &r;\\n ptr->draw(); // Calls Rectangle's draw\\n\\n return 0;\\n }\\n ```\\n\\n **Explanation:**\\n - `Shape` is an abstract class because it contains the pure virtual function `draw()`.\\n - `Circle` and `Rectangle` override `draw()`, so they become concrete classes and can be instantiated.\\n - Using a base class pointer, runtime polymorphism is achieved: the correct overridden `draw()` is invoked based on the actual object type.\\n\\n \\n A pure virtual function may still have a body (definition) in the base class, but the derived class must override it to become a concrete class.\"}]}}]} />\n\nshow(); return 0; {\\\"}\\\"}\",\"options\":[\"Base\",\"Compilation error\",\"Derived\",\"Undefined\"],\"answer\":2,\"hint\":\"Consider the binding time of function calls using pointers.\",\"explanation\":\"When a base class pointer points to a derived class object and calls a virtual function, the derived class version is executed. This is because the function is resolved at run time based on the actual object type.\"},{\"id\":\"690601ba-a823-4aed-a510-4ea1baf02142\",\"q\":\"Which of the following is NOT a rule for virtual functions?\",\"options\":[\"They must be members of some class.\",\"They can have different return types if the return type is a pointer or reference to a base/derived class.\",\"They must have the same signature in derived class.\",\"They cannot be declared as static.\"],\"answer\":1,\"hint\":\"Check the return type requirement for overriding.\",\"explanation\":\"A virtual function in base and derived class must have the same name, signature (parameters), and return type. An exception is covariant return types (pointers/references to related classes).\"},{\"id\":\"3fc2b179-d626-43a1-a8cf-744645a3a875\",\"q\":\"If a derived class does not override a virtual function of the base class, then a call to that function using a base class pointer pointing to derived object will execute:\",\"options\":[\"Derived class version\",\"Compilation error\",\"Nothing\",\"Base class version\"],\"answer\":3,\"hint\":\"When the base class pointer points to a derived object, which virtual function is called?\",\"explanation\":\"If virtual function is not overridden in the derived class, the base class version is invoked because there is no overridden version in the derived class.\"},{\"id\":\"54356ea8-0dd2-41fb-a7ea-41dc11436b8f\",\"q\":\"The syntax for declaring a pure virtual function is:\",\"options\":[\"virtual void func() = 0;\",\"virtual void func() = 1;\",\"pure virtual void func();\",\"virtual void func() pure;\"],\"answer\":0,\"hint\":\"A pure virtual function has no definition in the base class.\",\"explanation\":\"A pure virtual function is declared by assigning 0 in its declaration (e.g., virtual void func() is 0;). It makes the class abstract.\"},{\"id\":\"63d8ec64-1b8d-43a0-90f7-ed8d29eee42e\",\"q\":\"Why should destructors be declared virtual in a base class?\",\"options\":[\"To allow overloading of destructors.\",\"It is mandatory for all classes.\",\"To ensure proper cleanup of derived class objects when deleted through a base pointer.\",\"To increase performance.\"],\"answer\":2,\"hint\":\"Destructors are often made virtual when using inheritance.\",\"explanation\":\"If a base class pointer points to a derived object and the destructor is not virtual, only the base destructor runs (causing resource leak). With virtual destructor, the derived destructor runs first, then the base.\"},{\"id\":\"95a2c52f-5cd4-4449-aab7-afb96eb67d87\",\"q\":\"The internal mechanism that supports run-time polymorphism in C++ is:\",\"options\":[\"Function overloading table\",\"Virtual table (vtable)\",\"Inheritance table\",\"Dynamic dispatch stack\"],\"answer\":1,\"hint\":\"Think about the mechanism that supports dynamic dispatch.\",\"explanation\":\"C++ compilers typically implement virtual functions using a table of function pointers, called a vtable, to resolve the correct function at run time.\"},{\"id\":\"f55fa59d-d647-4396-a462-f2380d0f8dba\",\"q\":\"Which of the following is true about virtual functions?\",\"options\":[\"Virtual functions are always inline.\",\"A virtual function can be a friend function of another class.\",\"Virtual functions can be constructors.\",\"They must be non-static member functions of the class.\"],\"answer\":3,\"hint\":\"Recall the access rule for constructors.\",\"explanation\":\"Constructors are never virtual in C++. Virtual functions are called on an existing object, but constructors are meant to create objects and cannot be virtual.\"}]} topicId=\"4.5\" />\n" }) })] }); } 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."); }