"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h3: "h3", li: "li", p: "p", pre: "pre", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }, {DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, Intuition, KeyPoints, MCQ, Remember, SubTopicHeader, TopicOverview} = _components; 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 (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "1.6", title: "Class & Object: Introduction, Specifying a class, Access specifiers, Defining member functions: Inside class and Outside class, Creating objects, Memory allocations for objects" }), "\n", _jsxs(TopicOverview, { title: "Class & Object: Core Concepts and Usage", topicId: "1.6", readingTime: "8 min read", difficulty: "Medium", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Assembly Language Programming Tools" }), " form the core software pipeline required to transform human‑readable assembly instructions into a fully executable machine program. A processor cannot run raw assembly code (", _jsx(_components.code, { children: ".asm" }), ") directly — it requires a structured toolchain consisting of four specialized tools: ", _jsx(_components.strong, { children: "Editor" }), ", ", _jsx(_components.strong, { children: "Assembler" }), ", ", _jsx(_components.strong, { children: "Linker" }), ", and ", _jsx(_components.strong, { children: "Debugger" }), ". ⚙️"] }), _jsx(_components.p, { children: "In this subtopic, we will systematically examine how each of these four tools functions and how they collaborate to turn your source code into a running application." }), _jsxs(Intuition, { title: "The Recipe‑to‑Feast Pipeline", children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Think of this toolchain like cooking a gourmet meal 🍳:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Editor:" }), " Writing down the raw recipe instructions (source code)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assembler:" }), " Prepping raw ingredients into standardized usable portions (object code)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linker:" }), " Combining all prepped ingredients into a single complete dish (executable binary)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Debugger:" }), " Taste‑testing and refining the dish to fix any unexpected errors before serving."] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Editor:" }), " Creating and editing ", _jsx(_components.code, { children: ".asm" }), " source code files."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assembler:" }), " Translating mnemonics into machine‑readable object files (", _jsx(_components.code, { children: ".obj" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linker:" }), " Resolving memory references and linking libraries into an executable (", _jsx(_components.code, { children: ".exe" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Debugger:" }), " Stepping through execution to inspect registers, flags, and memory addresses."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Assembly Language Programming Tools" }), " woh zaroori software ecosystem hai jo human-written assembly instructions ko CPU dwara execute hone wale binary program mein convert karta hai. Processor assembly code (", _jsx(_components.code, { children: ".asm" }), ") ko direct execute nahi kar sakta — ise source code ko machine instructions mein badalane, link karne, aur test karne ke liye chaar vishesh tools ki zaroorat hoti hai: ", _jsx(_components.strong, { children: "Editor" }), ", ", _jsx(_components.strong, { children: "Assembler" }), ", ", _jsx(_components.strong, { children: "Linker" }), ", aur ", _jsx(_components.strong, { children: "Debugger" }), ". ⚙️"] }), _jsx(_components.p, { children: "Is subtopic mein hum bohot hi systematic tarike se samjhenge ki yeh chaaron tools kaise kaam karte hain aur milkar aapke source code ko ek working application mein kaise badalte hain." }), _jsxs(Intuition, { title: "The Recipe‑to‑Feast Pipeline", children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Aap is poore toolchain ko ek khana banane ke process 🍳 se samajh sakte hain:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Editor:" }), " Pehle aap recipe likhte hain (source code)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assembler:" }), " Raw ingredients ko chop aur prep karke standardized form mein rakhte hain (object code)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linker:" }), " Sabhi prepped items ko milaakar ek final complete dish banate hain (executable binary)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Debugger:" }), " Taste-test karke check karte hain taaki koi kami ya error turant fix ho sake."] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Editor:" }), " ", _jsx(_components.code, { children: ".asm" }), " source code files ko likhna aur modify karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assembler:" }), " Assembly mnemonics ko machine‑readable object files (", _jsx(_components.code, { children: ".obj" }), ") mein translate karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linker:" }), " Memory references resolve karke aur libraries jodkar ek ", _jsx(_components.code, { children: ".exe" }), " executable file banana."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Debugger:" }), " Program ke execution ko step‑by‑step track karke registers, flags, aur memory ko inspect karna."] }), "\n"] })] })] }), "\n", _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Class", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["🛥️ A ", _jsx(_components.strong, { children: "Class" }), " is a user‑defined data type that groups together data members (attributes) and member functions (behaviors) under a single logical unit."] }), _jsx(Intuition, { title: "The Blueprint Analogy", children: _jsxs(_components.p, { children: ["Think of a ", _jsx(_components.strong, { children: "class" }), " as an architectural blueprint 🏗️: it defines the structure (rooms, walls, doors) and the intended functions (how to open a door) but does not create any physical building yet."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["एक ", _jsx(_components.strong, { children: "Class" }), " एक user-defined data type hai jo data members (attributes) aur member functions (behaviors) ko ek single logical unit ke andar bundle karta hai."] }), _jsx(Intuition, { title: "The Blueprint‑and‑Individual Analogy", children: _jsx(_components.p, { children: "Aap isko ek architectural blueprint 🏗️ se samajh sakte hain: yeh structure define karta hai (rooms, walls, doors) aur intended functions (doors kaise kholna) magar abhi tak koi physical building nahi banaya." }) })] })] }), _jsxs(DefinitionEntry, { term: "Object", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "Object" }), " is an instance of a class that occupies memory and holds concrete values for its data members."] }), _jsx(Intuition, { title: "The Completed House", children: _jsxs(_components.p, { children: ["Imagine a ", _jsx(_components.strong, { children: "class" }), " as a house design, while an ", _jsx(_components.strong, { children: "object" }), " is the actual built house 🏡 where each room has furniture (data) and a resident (behavior) ready to use."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["एक ", _jsx(_components.strong, { children: "Object" }), " class ka ek instance hai jo memory occupy karta hai aur apne data members ke liye concrete values ko hold karta hai."] }), _jsx(Intuition, { title: "The Completed House", children: _jsx(_components.p, { children: "Aap ek design (blueprints) se liye ek build home ka analog bana sakte hain — blueprint define karta hai, object use karta hai (rooms me furniture, doors kaise kholna) real world me." }) })] })] }), _jsxs(DefinitionEntry, { term: "Access Specifier", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "Access Specifier" }), " (", _jsx(_components.code, { children: "public" }), ", ", _jsx(_components.code, { children: "private" }), ", ", _jsx(_components.code, { children: "protected" }), ") controls the visibility and accessibility of class members from inside and outside the class."] }), _jsx(Intuition, { title: "Room Access Rules", children: _jsxs(_components.p, { children: ["It's like room access in a house: ", _jsx(_components.code, { children: "public" }), " rooms (living room) everyone can enter, ", _jsx(_components.code, { children: "private" }), " rooms (bedroom) only owners, and ", _jsx(_components.code, { children: "protected" }), " rooms shared with close relatives."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Access Specifier" }), " (", _jsx(_components.code, { children: "public" }), ", ", _jsx(_components.code, { children: "private" }), ", ", _jsx(_components.code, { children: "protected" }), ") class members ke visibility aur accessibility ko control karta hai — class ke andar se ya bahar se."] }), _jsx(Intuition, { title: "Room Access Rules", children: _jsxs(_components.p, { children: ["Isse aap ek house ke rooms se compare karsakte hain: ", _jsx(_components.code, { children: "public" }), " room everyone may enter, ", _jsx(_components.code, { children: "private" }), " room only owners, ", _jsx(_components.code, { children: "protected" }), " is sometimes shared."] }) })] })] }), _jsxs(DefinitionEntry, { term: "Member Function (Inside/Outside)", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "Member Function" }), " is a function that belongs to a class and can operate on its data members."] }), _jsx(Intuition, { title: "House Mechanic", children: _jsxs(_components.p, { children: ["You can think of a member function as a ", _jsx(_components.strong, { children: "house mechanic" }), " that knows how the house works: it can open doors, turn lights on, or fix a leak."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Member Function" }), " ek function hai jo class ke andar define hoti hai aur class data members par operate kar sakti hai."] }), _jsx(Intuition, { title: "House Mechanic", children: _jsx(_components.p, { children: "Isse aap ek house mechanic se compare karsakte hain: to class ke andar, door, lights, leak fix kare." }) })] })] }), _jsxs(DefinitionEntry, { term: "Creating an Object", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["Creating an ", _jsx(_components.strong, { children: "Object" }), " involves declaring a variable of the class type, e.g., ", _jsx(_components.code, { children: "ClassName obj1;" }), " which reserves storage for that instance."] }), _jsx(Intuition, { title: "Reserving a Room", children: _jsxs(_components.p, { children: ["This is like reserving a room in a hotel: you declare ", _jsx(_components.code, { children: "RoomType room;" }), " to ensure a space is set aside for you."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Creating an Object" }), " karne ka matlab class type variable declare karna: ", _jsx(_components.code, { children: "ClassName obj1;" }), " jisse us instance ke liye memory allocate ho jati hai."] }), _jsx(Intuition, { title: "Reserving a Room", children: _jsx(_components.p, { children: "Isse hotel room ka analogy laga sakte hain: RoomType room; reserve." }) })] })] }), _jsxs(DefinitionEntry, { term: "Memory Allocation for Objects", children: [_jsxs(English, { children: [_jsx(_components.p, { children: "When an object is created, the class’s non‑static data members are allocated memory based on their types, while static members are shared among all objects." }), _jsx(Intuition, { title: "Packing a Suitcase", children: _jsx(_components.p, { children: "Think of object creation as packing a suitcase 🧳: each item (data member) gets its own space, while shared items (like a family photo) travel with you." }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.p, { children: "Object creation par, class ke non-static data members ki types ke hisab se memory allocate hoti hai, jabki static members sabhi objects ke liye share hote hain." }), _jsx(Intuition, { title: "Packing a Suitcase", children: _jsx(_components.p, { children: "Isse suitcases ko compare karsakte hain: each item unique (data), shared items common (family photo)." }) })] })] })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Specifying a Class" }), _jsxs(_components.p, { children: ["⚙️ The class definition begins with the keyword ", _jsx(_components.code, { children: "class" }), " followed by the class name and a body enclosed in braces ", _jsx(_components.code, { children: "{}" }), ". Inside the body you declare data members, access specifiers, and member functions."] }), _jsxs(_components.p, { children: ["📌 ", _jsx(_components.strong, { children: "Typical Class Structure" })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Employee {\n // data members\n string name;\n int id;\npublic: // access specifier\n // member functions\n void setDetails(string n, int i) {\n name = n;\n id = i;\n }\n void display() {\n cout << \"Name: \" << name << \", ID: \" << id;\n }\n};\n" }) }), _jsxs(_components.p, { children: ["This snippet shows a class ", _jsx(_components.code, { children: "Employee" }), " containing two ", _jsx(_components.code, { children: "private" }), " data members (by default) and two ", _jsx(_components.code, { children: "public" }), " member functions."] }), _jsx(_components.h3, { children: "Defining Member Functions" }), _jsxs(_components.p, { children: ["Member functions can be defined ", _jsx(_components.strong, { children: "inside" }), " the class (inline) or ", _jsx(_components.strong, { children: "outside" }), " (traditional definition). Inside definition is concise, while outside definition separates declaration from implementation."] }), _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Imagine an apartment building: the ", _jsx(_components.strong, { children: "definition inside" }), " the class is like putting a maintenance guide on each floor, while an ", _jsx(_components.strong, { children: "outside definition" }), " is a separate handbook kept in the lobby."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Inside class definition" }), " (inline):"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Point {\n int x, y;\npublic:\n void set(int a, int b) {\n x = a; y = b; // direct assignment\n }\n int getX() { return x; }\n};\n" }) }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Outside class definition" }), " (traditional):"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Circle {\n float radius;\npublic:\n void setRadius(float r) {\n radius = r;\n }\n};\n\n// Outside definition\nvoid Circle::setRadius(float r) {\n radius = r; // using the member directly\n}\n" }) }), _jsx(_components.h3, { children: "Access Specifiers in Detail" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "public" }), ": Members are accessible from any part of the program."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "private" }), ": Members can only be accessed by member functions of the class."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "protected" }), ": Similar to ", _jsx(_components.code, { children: "private" }), ", but also accessible in derived (child) classes."] }), "\n"] }), _jsx(Intuition, { title: "Encapsulation as a Safe", children: _jsxs(_components.p, { children: ["🧠 Encapsulation is like keeping valuables in a safe: ", _jsx(_components.code, { children: "public" }), " parts are the displayed information, while ", _jsx(_components.code, { children: "private" }), " sections are locked away."] }) }), _jsx(_components.h3, { children: "Creating Objects" }), _jsx(_components.p, { children: "After the class is defined, you can instantiate objects using the class name followed by the object identifier:" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "Employee emp1, emp2; // two Employee objects\nemp1.setDetails(\"Ravi\", 101);\nemp2.setDetails(\"Meena\", 102);\nemp1.display(); // prints Ravi, 101\nemp2.display(); // prints Meena, 102\n" }) }), _jsx(Intuition, { title: "Objects as Real‑World Instances", children: _jsx(_components.p, { children: "🎯 Think of objects as individual people in a family: the class defines the family template (parents, siblings), while each object is a unique child with its own name and traits." }) }), _jsx(_components.h3, { children: "Memory Allocation Overview" }), _jsx(_components.p, { children: "When the program runs, the memory layout for each object looks like this (simplified diagram):" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TB\n A[Object emp1] --> B[Data Members: name, id]\n A --> C[Member Functions: setDetails(), display()]\n D[Object emp2] --> B\n D --> C\n" }) }), _jsx(_components.p, { children: "Each object owns its data members; member functions are shared across all objects of that class. Static members, if declared, appear only once in memory and are accessible through any object." }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["A ", _jsx(_components.strong, { children: "class" }), " is a blueprint; an ", _jsx(_components.strong, { children: "object" }), " is a concrete instance."] }), "\n", _jsxs(_components.li, { children: ["Access specifiers (", _jsx(_components.code, { children: "public" }), ", ", _jsx(_components.code, { children: "private" }), ", ", _jsx(_components.code, { children: "protected" }), ") control visibility."] }), "\n", _jsx(_components.li, { children: "Member functions can be defined inline inside the class or traditionally outside." }), "\n", _jsx(_components.li, { children: "Object creation reserves memory for non‑static members, while static members remain shared." }), "\n"] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["🚫 ", _jsx(_components.strong, { children: "Common Pitfall:" }), " Defining a member function outside the class but forgetting the scope resolution operator ", _jsx(_components.code, { children: "ClassName::" }), " leads to a compilation error."] }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Class ko specify karna" }), _jsxs(_components.p, { children: ["⚙️ Class definition ka shuruwaat ", _jsx(_components.code, { children: "class" }), " keyword se hoti hai, uske baad class name aur ", _jsx(_components.code, { children: "{}" }), " braces ke andar class body hoti hai. Body ke andar data members, access specifiers, aur member functions declare ki jaate hain."] }), _jsxs(_components.p, { children: ["📌 ", _jsx(_components.strong, { children: "Class Structure ka example" })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Employee {\n // data members\n string name;\n int id;\npublic: // access specifier\n // member functions\n void setDetails(string n, int i) {\n name = n;\n id = i;\n }\n void display() {\n cout << \"Name: \" << name << \", ID: \" << id;\n }\n};\n" }) }), _jsxs(_components.p, { children: ["Yah class ", _jsx(_components.code, { children: "Employee" }), " ke do data members (default ", _jsx(_components.code, { children: "private" }), ") aur do public member functions dikhata hai."] }), _jsx(_components.h3, { children: "Member functions define karna" }), _jsxs(_components.p, { children: ["Member functions ko class ke andar ", _jsx(_components.strong, { children: "inline" }), " define kiya ja sakta hai ya ", _jsx(_components.strong, { children: "class ke bahar" }), " paramparagat tarike se define kiya ja sakta hai. Inside definition short aur readable hota hai, jabki outside definition implementation ko declaration se alag karta hai."] }), _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Isko ek apartment building se compare karo: ", _jsx(_components.strong, { children: "class ke andar define" }), " karna floor par maintenance guide rakhtaa hai, jabki ", _jsx(_components.strong, { children: "class ke bahar define" }), " karna lobby mein rakhta hai ek different handbook."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Inside class (inline):" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Point {\n int x, y;\npublic:\n void set(int a, int b) {\n x = a; y = b;\n }\n int getX() { return x; }\n};\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Outside class (traditional):" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "class Circle {\n float radius;\npublic:\n void setRadius(float r) {\n radius = r;\n }\n};\n\n// Bahar define\nvoid Circle::setRadius(float r) {\n radius = r;\n}\n" }) }), _jsx(_components.h3, { children: "Access specifiers ka detail" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "public" }), ": Members program ke kisi bhi part se accessible hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "private" }), ": Members ke sirf class ke member functions access kar sakte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "protected" }), ": ", _jsx(_components.code, { children: "private" }), " ke same par derived classes (child) bhi accessible hote hain."] }), "\n"] }), _jsx(Intuition, { title: "Encapsulation ek Safe ki tarah hota hai", children: _jsxs(_components.p, { children: ["🧠 Encapsulation ko ek safe se compare karo: ", _jsx(_components.code, { children: "public" }), " parts displayed hote hain, jabki ", _jsx(_components.code, { children: "private" }), " sections locked hote hain."] }) }), _jsx(_components.h3, { children: "Objects create karna" }), _jsxs(_components.p, { children: ["Class definition ke baad objects instantiate karte hain class name se: ", _jsx(_components.code, { children: "ClassName obj;" })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-cpp", children: "Employee emp1, emp2;\nemp1.setDetails(\"Ravi\", 101);\nemp2.setDetails(\"Meena\", 102);\nemp1.display(); // prints Ravi, 101\nemp2.display(); // prints Meena, 102\n" }) }), _jsx(Intuition, { title: "Objects real world instances", children: _jsx(_components.p, { children: "🎯 Objects ko family ke members se compare karo: class family template define karta hai, har object unique name, traits ke sath." }) }), _jsx(_components.h3, { children: "Memory allocation overview" }), _jsx(_components.p, { children: "Program run time par, har object ke liye memory layout jaise:" }), _jsx(_components.p, { children: "Har object apne data members ke liye memory allocate karta hai; member functions sabhi objects ke liye share hote hain. Agar static members declare kiye gaye hain, to woh sirf ek baar memory allocate hote hain aur kisi bhi object se accessible hote hain." }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Class" }), " blueprint hai; ", _jsx(_components.strong, { children: "object" }), " concrete instance."] }), "\n", _jsxs(_components.li, { children: ["Access specifiers (", _jsx(_components.code, { children: "public" }), ", ", _jsx(_components.code, { children: "private" }), ", ", _jsx(_components.code, { children: "protected" }), ") visibility control karte hain."] }), "\n", _jsx(_components.li, { children: "Member functions inside ya class ke bahar define ki ja sakti hain." }), "\n", _jsx(_components.li, { children: "Object creation non-static members ke liye memory allocate karta hai; static members shared hote hain." }), "\n"] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["🚫 ", _jsx(_components.strong, { children: "Common mistake:" }), " Class ke bahar define ki gayi function for class but scope resolution operator ", _jsx(_components.code, { children: "ClassName::" }), " forget → compilation error."] }) })] }), _jsx(Intuition, { title: "Object Memory Layout Diagram", children: _jsx(_components.p, { children: "🧠 Visualising object memory: each object occupies its own data slot while sharing class code (member functions) – akin to multiple houses sharing a single community hall." }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Define a class and an object and explain how an object occupies memory.", "marks": 2, "a": { "components": [{ "type": "Explanation", "content": "🏫 Definition\n A **class** is a user‑defined data type that serves as a blueprint for creating objects. It groups **data members** (attributes) and **member functions** (behaviour) together.\n An **object** is an instance of a class; it holds concrete values for its data members and can invoke member functions.\n When an object is created, memory is allocated as the sum of the sizes of its data members, plus any padding required for alignment. Each object receives its own separate block of memory, independent of other objects of the same class.\n \n Remember, the class itself does not occupy runtime memory; only its objects do!" }] } }, { "q": "Describe access specifiers in a class and give examples of their use.", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "🔐 Access Specifiers\n \n **Public** – members are accessible from anywhere, inside or outside the class.\n **Private** – members are accessible only within the class definition itself.\n **Protected** – members are accessible within the class and by derived classes (inheritance).\n \n Typical usage:\n \n{`class Car {\npublic:\n string brand; // can be read/written anywhere\nprivate:\n int speed; // only Car's methods can modify\nprotected:\n string color; // accessible in Car and its derived classes\n};`}" }] } }, { "q": "Write a C++ program that defines a class 'Student' with two data members (name, roll) and two member functions: one to read data (inside class) and another to display (outside class). Also, create two objects and call the display function for each.", "marks": 6, "a": { "components": [{ "type": "Explanation", "content": "💻 Complete Program\n Below is the full source code. It demonstrates defining a class, a member function inside the class (`readData`) and a free function (`displayStudent`) defined outside the class.\n \n{`class Student {\npublic:\n string name;\n int roll;\n\n // Member function defined inside class\n void readData() {\n cout << \"Enter name: \";\n cin >> name;\n cout << \"Enter roll: \";\n cin >> roll;\n }\n};\n\n// Member function defined outside class\nvoid displayStudent(Student s) {\n cout << \"Name: \" << s.name << \", Roll: \" << s.roll << endl;\n}\n\nint main() {\n // Create two objects\n Student s1, s2;\n\n // Read data using member function\n cout << \"--- Entering data for Student 1 ---\" << endl;\n s1.readData();\n cout << \"--- Entering data for Student 2 ---\" << endl;\n s2.readData();\n\n // Display data using external function\n cout << \"\\\\n--- Displaying Student 1 ---\" << endl;\n displayStudent(s1);\n cout << \"--- Displaying Student 2 ---\" << endl;\n displayStudent(s2);\n\n return 0;\n}`}\n \n \n Key Points\n \n Class `Student` holds `string name` and `int roll`.\n `readData()` is a member function defined inside the class.\n `displayStudent()` is defined outside the class, taking a `Student` object by value.\n Two objects (`s1`, `s2`) are created in `main()` and their data is read and shown." }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "b4e33ee0-2d5c-4973-aef2-3a65b67443c7", "q": "Which keyword is used to declare a class in C++?", "options": ["class", "struct", "union", "typename"], "answer": 0, "hint": "Think of the word used to define a user-defined type.", "explanation": "The keyword 'class' precedes the class name to create a new class type." }, { "id": "dc1290b3-39b7-41fd-ad7c-d33a0f62a5b3", "q": "Which access specifier is the default for class members in a user-defined class?", "options": ["public", "private", "protected", "static"], "answer": 1, "hint": "Remember which members are hidden by default.", "explanation": "Class members are private by default, ensuring data encapsulation." }, { "id": "f8724023-f431-43dd-a5f0-8a887da659ac", "q": "Inside which scope are member functions defined if they are declared within the class body?", "options": ["global scope", "class scope", "file scope", "namespace scope"], "answer": 1, "hint": "Think where the definition is placed.", "explanation": "Member functions declared inside the class are defined in the class scope." }, { "id": "aed2a548-385b-48e3-9ca5-98eb7e404ad3", "q": "Which syntax creates an object of class MyClass on the stack?", "options": ["MyClass obj;", "new MyClass;", "&MyClass obj;", "MyClass *ptr;"], "answer": 0, "hint": "Recall typical object creation statements.", "explanation": "Declaring a variable of class type invokes the default constructor and allocates memory on the stack." }, { "id": "abb5ade3-8566-4641-92b9-73d758b9d0ec", "q": "What is stored in memory for each object of a class?", "options": ["only its data members", "only its member functions", "both data members and functions", "no memory"], "answer": 2, "hint": "Both the object's data and its function definitions occupy space.", "explanation": "Each object contains a copy of its data members and a pointer to its member functions (if defined outside)." }, { "id": "a9dfc1c5-462c-4a41-bb3d-39615f36477f", "q": "Which of the following best describes a static member variable?", "options": ["belongs to each object individually", "exists only for the class but not shared", "shared across all objects of the class", "is a constant only"], "answer": 2, "hint": "Think of a variable that all objects can access together.", "explanation": "A static member variable is allocated once for the entire class and is shared by all its objects." }, { "id": "0242cf87-2d0b-4a88-a545-fcdb440967ce", "q": "Which syntax is used to define a member function outside its class?", "options": ["Scope resolution operator (::)", "Friend keyword", "Inline keyword", "Virtual keyword"], "answer": 0, "hint": "Look for the operator that connects the class name and function name.", "explanation": "Member functions defined outside the class use the scope resolution operator to associate them with the class." }, { "id": "14c18d80-15cf-4dd0-b2b4-5f26e775e228", "q": "What is the default access specifier for a class in C++?", "options": ["public", "private", "protected", "static"], "answer": 1, "hint": "Recall which members are hidden unless specified.", "explanation": "By default, class members are private, providing better encapsulation." }, { "id": "2e7bc566-5646-4458-b213-197916182a30", "q": "What is the typical size (in bytes) of an object containing a single int data member?", "options": ["0", "1", "4", "Depends on implementation"], "answer": 2, "hint": "Consider the size of an int on most compilers.", "explanation": "On a 32‑bit system, an int occupies 4 bytes, so a simple object with just that member is usually 4 bytes." }, { "id": "9949db72-2958-47c3-a2ca-1cf36d9ac8c1", "q": "Which statement about a friend function is true?", "options": ["It is a member of the class", "It can access private members of the class", "It cannot be static", "It overrides a base class method"], "answer": 1, "hint": "Think of a function that helps the class without being owned by it.", "explanation": "A friend function is external to the class but is granted access to its private and protected members." }], topicId: "1.6" })] }); } 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."); }