"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", li: "li", ol: "ol", p: "p", pre: "pre", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Analogy, Answer, Applications, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, HowItWorks, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Analogy) _missingMdxReference("Analogy", true); if (!Answer) _missingMdxReference("Answer", true); if (!Applications) _missingMdxReference("Applications", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", 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 (!HowItWorks) _missingMdxReference("HowItWorks", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "3.1", title: "Static vs Dynamic Memory Allocation" }), _jsx(English, { children: _jsx(TopicOverview, { title: "Static and Dynamic Memory Allocation", topicId: "3.1", readingTime: "7 min read", difficulty: "Medium", children: _jsx(_components.p, { children: "Memory allocation is how the computer reserves space for storing data during program execution. There are two types: static allocation, where the size is fixed at compile time, and dynamic allocation, where memory is allocated and freed during runtime as needed. Understanding this difference is essential before studying linked lists, which rely entirely on dynamic memory." }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "Static aur Dynamic Memory Allocation", topicId: "3.1", readingTime: "7 min read", difficulty: "Medium", children: _jsx(_components.p, { children: "Memory allocation wo process hai jismein computer program ke execution ke dauran data store karne ke liye space reserve karta hai. Do types hain: static allocation jismein size compile time par fix hota hai, aur dynamic allocation jismein runtime par memory need ke hisaab se allocate aur free hoti hai. Yeh difference samajhna linked list padhne se pehle zaroori hai jo poora dynamic memory par depend karti hai." }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Static Memory Allocation", children: _jsx(_components.p, { children: "In static allocation, memory is allocated at compile time with a fixed size that cannot change during execution. Hinglish: Static allocation mein memory compile time par ek fixed size ke saath allocate hoti hai jo execution ke dauran change nahi ho sakti. Example: int arr[100]; reserves exactly 100 integers always." }) }), _jsx(DefinitionEntry, { term: "Dynamic Memory Allocation", children: _jsx(_components.p, { children: "In dynamic allocation, memory is allocated at runtime using functions like malloc() or calloc(), and can be freed when no longer needed. Hinglish: Dynamic allocation mein memory runtime par malloc() ya calloc() jaise functions se allocate hoti hai, aur zaroorat khatam hone par free ki ja sakti hai." }) }), _jsx(DefinitionEntry, { term: "Heap", children: _jsx(_components.p, { children: "The heap is a region of memory used for dynamic allocation, where blocks are allocated and freed in any order. Hinglish: Heap wo memory region hai jo dynamic allocation ke liye use hota hai, jahan blocks kisi bhi order mein allocate aur free ho sakte hain." }) }), _jsx(DefinitionEntry, { term: "Stack", children: _jsx(_components.p, { children: "The stack is a region of memory used for static allocation and function call management, following LIFO order. Hinglish: Stack wo memory region hai jo static allocation aur function call management ke liye use hota hai, jo LIFO order follow karta hai." }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx("h3", { children: "📌 Static Memory Allocation — Fixed Size, Fast Access" }), _jsx("p", { children: "Static memory allocation is like reserving a fixed number of seats in a classroom before the semester starts. The compiler decides exactly how much memory is needed when the program is written, and allocates it before the program even runs. You cannot add more seats later." }), _jsxs("p", { children: [_jsx("strong", { children: "How it works:" }), " When you write int arr[100], the compiler reserves space for exactly 100 integers on the stack. This memory is allocated when the function is called and automatically freed when the function returns. No manual management needed."] }), _jsx("p", { children: _jsx("strong", { children: "Advantages:" }) }), _jsx("p", { children: "• Fast — memory access is immediate because the compiler knows exact addresses at compile time." }), _jsx("p", { children: "• Simple — no need to worry about memory leaks or freeing memory." }), _jsx("p", { children: "• Automatic — allocation and deallocation happen automatically when functions start and end." }), _jsx("p", { children: _jsx("strong", { children: "Disadvantages:" }) }), _jsx("p", { children: "• Inflexible — you cannot change the size during program execution." }), _jsx("p", { children: "• Wasteful — if you allocate 1000 elements but only use 10, the remaining 990 are wasted." }), _jsx("p", { children: "• Risk of overflow — if you allocate too few elements and the program needs more, you get a buffer overflow (dangerous bug!)." }), _jsxs("p", { children: [_jsx("strong", { children: "Where it happens:" }), " Static allocation uses the STACK memory region. The stack is a fast, LIFO (Last In First Out) structure managed by the operating system."] }), _jsxs("p", { children: [_jsx("strong", { children: "Example:" }), " int marks[50]; — always reserves space for exactly 50 integers. Can never be 51 or 49."] })] }), _jsxs(Hinglish, { children: [_jsx("h3", { children: "📌 Static Memory Allocation — Fixed Size, Fast Access" }), _jsx("p", { children: "Static memory allocation bilkul ek class mein semester shuru hone se pehle fixed seats reserve karne jaisa hai. Compiler program likhte waqt exactly kitni memory chahiye yeh decide kar leta hai, aur program run hone se pehle hi allocate kar deta hai. Aap baad mein zyada seats add nahi kar sakte." }), _jsxs("p", { children: [_jsx("strong", { children: "Kaise kaam karta hai:" }), " Jab aap int arr[100] likhte hain toh compiler stack par exactly 100 integers ke liye space reserve karta hai. Yeh memory function call hone par allocate hoti hai aur function return hone par automatically free ho jaati hai. Koi manual management ki zaroorat nahi."] }), _jsx("p", { children: _jsx("strong", { children: "Faayde:" }) }), _jsx("p", { children: "• Fast — memory access turant hota hai kyunki compiler ko compile time par exact addresses pata hote hain." }), _jsx("p", { children: "• Simple — memory leaks ya free karne ki chinta nahi." }), _jsx("p", { children: "• Automatic — allocation aur deallocation functions start aur end hone par automatically hota hai." }), _jsx("p", { children: _jsx("strong", { children: "Nuksan:" }) }), _jsx("p", { children: "• Inflexible — program execution ke dauran size change nahi kar sakte." }), _jsx("p", { children: "• Wasteful — agar aapne 1000 elements allocate kiye lekin sirf 10 use kiye toh baaki 990 waste hain." }), _jsx("p", { children: "• Overflow ka khatra — agar aapne kam elements allocate kiye aur program ko zyada chahiye toh buffer overflow hota hai (khatarnak bug!)." }), _jsxs("p", { children: [_jsx("strong", { children: "Kahan hota hai:" }), " Static allocation STACK memory region use karta hai. Stack ek fast, LIFO (Last In First Out) structure hai jo operating system manage karta hai."] }), _jsxs("p", { children: [_jsx("strong", { children: "Example:" }), " int marks[50]; — hamesha 50 integers ke liye space reserve karta hai. Kabhi 51 ya 49 nahi ho sakta."] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Memory size is fixed at compile time — cannot be changed later." }), "\n", _jsx(_components.li, { children: "Allocation and deallocation happen automatically (when function starts/ends)." }), "\n", _jsx(_components.li, { children: "Uses the STACK memory region — very fast access." }), "\n", _jsx(_components.li, { children: "No memory leaks possible (automatic cleanup)." }), "\n", _jsx(_components.li, { children: "Risk: Buffer overflow if you allocate too little memory." }), "\n", _jsx(_components.li, { children: "Risk: Memory waste if you allocate too much memory." }), "\n"] }) }), _jsxs(English, { children: [_jsx("h3", { children: "⚡ Dynamic Memory Allocation — Flexible Size, Manual Control" }), _jsx("p", { children: "Dynamic memory allocation is like renting a hotel room — you decide how many rooms you need at runtime, and you can get more or give back rooms as your needs change. You request memory from the heap (a large pool of free memory) when you need it, and return it when you're done." }), _jsxs("p", { children: [_jsx("strong", { children: "How it works in C:" }), " You use functions from stdlib.h:"] }), _jsxs("p", { children: [_jsx("strong", { children: "malloc(size)" }), " — Allocates \"size\" bytes of memory. The memory is NOT initialized (it contains garbage values). Returns a pointer to the allocated memory, or NULL if allocation fails."] }), _jsxs("p", { children: [_jsx("strong", { children: "calloc(n, size)" }), " — Allocates memory for \"n\" elements, each \"size\" bytes. The memory IS initialized to zero. Returns a pointer, or NULL on failure."] }), _jsxs("p", { children: [_jsx("strong", { children: "free(ptr)" }), " — Releases the memory pointed to by ptr. After this, the memory can be reused. You must NOT use the pointer after freeing (dangling pointer)."] }), _jsxs("p", { children: [_jsx("strong", { children: "realloc(ptr, newSize)" }), " — Resizes a previously allocated block. Can grow or shrink the allocation. May copy data to a new location if the current block can't be extended."] }), _jsxs("p", { children: [_jsx("strong", { children: "Where it happens:" }), " Dynamic allocation uses the HEAP memory region. The heap is slower than the stack because the OS must search for free blocks and manage the memory pool."] }), _jsxs("p", { children: [_jsx("strong", { children: "Why it's essential:" }), " Data structures like linked lists, trees, and graphs grow and shrink during execution. You don't know in advance how many nodes you'll need. Dynamic allocation makes this possible."] })] }), _jsxs(Hinglish, { children: [_jsx("h3", { children: "⚡ Dynamic Memory Allocation — Flexible Size, Manual Control" }), _jsx("p", { children: "Dynamic memory allocation bilkul hotel room rent karne jaisa hai — aap runtime par decide karte hain kitne chahiye, aur apni need ke hisaab se zyada le sakte hain ya wapas de sakte hain. Aap heap (free memory ka bada pool) se tab memory maangte hain jab chahiye, aur kaam ho jaane par wapas karte hain." }), _jsxs("p", { children: [_jsx("strong", { children: "C mein kaise kaam karta hai:" }), " Aap stdlib.h ke functions use karte hain:"] }), _jsxs("p", { children: [_jsx("strong", { children: "malloc(size)" }), " — \"size\" bytes memory allocate karta hai. Memory initialized NAHI hoti (garbage values hoti hain). Allocated memory ka pointer return karta hai, ya agar allocation fail ho toh NULL."] }), _jsxs("p", { children: [_jsx("strong", { children: "calloc(n, size)" }), " — \"n\" elements ke liye memory allocate karta hai, har ek \"size\" bytes. Memory ZERO se initialized hoti hai. Pointer return karta hai, ya fail hone par NULL."] }), _jsxs("p", { children: [_jsx("strong", { children: "free(ptr)" }), " — ptr dwara point ki gayi memory release karta hai. Iske baad woh memory dobara use ho sakti hai. Pointer ko free karne ke baad use NAHI karna chahiye (dangling pointer)."] }), _jsxs("p", { children: [_jsx("strong", { children: "realloc(ptr, newSize)" }), " — Pehle se allocated block ka size change karta hai. Allocation badha ya ghat sakta hai. Agar current block extend nahi ho sakta toh data nayi jagah par copy kar sakta hai."] }), _jsxs("p", { children: [_jsx("strong", { children: "Kahan hota hai:" }), " Dynamic allocation HEAP memory region use karta hai. Stack ki tulna mein heap slow hota hai kyunki OS ko free blocks dhoondhne aur memory pool manage karna padta hai."] }), _jsxs("p", { children: [_jsx("strong", { children: "Kyun zaroori hai:" }), " Linked lists, trees, aur graphs jaise data structures execution ke dauran badhte aur ghatte hain. Aapko pehle se nahi pata kitne nodes chahenge. Dynamic allocation yeh possible banata hai."] })] }), _jsx(HowItWorks, { title: "Dynamic Allocation Step by Step", children: _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Ask user how many elements they need: scanf(\"%d\", &n)." }), "\n", _jsx(_components.li, { children: "Allocate memory: arr = (int *)malloc(n * sizeof(int))." }), "\n", _jsx(_components.li, { children: "Check if allocation succeeded: if (arr == NULL) handle error." }), "\n", _jsx(_components.li, { children: "Use the memory just like an array: arr[0], arr[1], etc." }), "\n", _jsx(_components.li, { children: "When done, release the memory: free(arr)." }), "\n", _jsx(_components.li, { children: "Set pointer to NULL: arr = NULL (good practice to prevent dangling pointer)." }), "\n"] }) }), _jsx(CodeBlock, { language: "c", children: `// Dynamic Memory Allocation — Full Example #include #include int main() { int n, i; int *arr; printf("How many elements? "); scanf("%d", &n); // Allocate memory dynamically arr = (int *)malloc(n * sizeof(int)); // Always check if allocation succeeded if (arr == NULL) { printf("Memory allocation failed!\\n"); return 1; } // Use the memory like a normal array for (i = 0; i < n; i++) { arr[i] = (i + 1) * 10; } printf("Values: "); for (i = 0; i < n; i++) { printf("%d ", arr[i]); } printf("\\n"); // Free the memory when done free(arr); arr = NULL; // Good practice return 0; } // If user enters 5: Output: Values: 10 20 30 40 50 // If user enters 3: Output: Values: 10 20 30 // Same program, different sizes — that's the power of dynamic allocation!` }), _jsx(CodeBlock, { language: "c", children: `// calloc vs malloc comparison #include #include int main() { int n = 5, i; // malloc — uninitialized (garbage values) int *a = (int *)malloc(n * sizeof(int)); printf("malloc: "); for (i = 0; i < n; i++) printf("%d ", a[i]); // Could be anything! // calloc — initialized to zero int *b = (int *)calloc(n, sizeof(int)); printf("\\ncalloc: "); for (i = 0; i < n; i++) printf("%d ", b[i]); // Always 0 0 0 0 0 free(a); free(b); return 0; }` }), _jsx(ComparisonTable, { title: "Static vs Dynamic Memory Allocation — Complete", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Feature" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Static Allocation" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Dynamic Allocation" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "When allocated" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Compile time" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Runtime" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Size" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fixed (cannot change)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Flexible (can resize with realloc)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Memory region" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Stack" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Heap" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Speed" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Faster (direct access)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Slower (OS manages heap)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Deallocation" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Automatic (when function returns)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Manual (must call free)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Memory leaks" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Impossible" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Possible if not freed" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Dangling pointers" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Not possible" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Possible if used after free" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Best for" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fixed-size data (arrays)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Variable-size data (linked lists, trees)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Example" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "int arr[100];" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "int *arr = malloc(n * sizeof(int));" })] })] })] }) }), _jsx(Remember, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Always check if malloc/calloc returns NULL before using the pointer." }), "\n", _jsx(_components.li, { children: "Always call free() when done with dynamic memory — or you'll have a memory leak." }), "\n", _jsx(_components.li, { children: "Never use a pointer after calling free() — this causes undefined behavior (dangling pointer)." }), "\n", _jsx(_components.li, { children: "Set the pointer to NULL after freeing — this prevents accidental reuse." }), "\n", _jsx(_components.li, { children: "Static allocation uses stack (fast, automatic); dynamic allocation uses heap (flexible, manual)." }), "\n", _jsx(_components.li, { children: "Linked lists REQUIRE dynamic allocation because their size changes during execution." }), "\n"] }) }), _jsx(Analogy, { children: _jsxs(_components.p, { children: [_jsx("b", { children: "Analogy: Booking a Hotel Room" }), _jsx("br", {}), "\n", _jsx("strong", { children: "Static allocation:" }), " You book a fixed room type (e.g., \"Deluxe for 2 people\") 6 months in advance. You get exactly that room — no more, no less. If 5 friends show up, 3 have nowhere to sleep. If only 1 person comes, you wasted space for another.", _jsx("br", {}), "\n", _jsx("strong", { children: "Dynamic allocation:" }), " You walk into the hotel and say \"I need rooms for my group.\" The front desk checks availability and gives you exactly what you need — 3 rooms for 5 people. When your friends leave, you return the rooms and only pay for what you used. But you must remember to check out (free the memory) or you'll be charged forever (memory leak)!"] }) }), _jsx(Applications, { title: "When to Use Each", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Static" }), ": Days of week (always 7), months (always 12), small fixed lookup tables, array of student records when class size is known."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dynamic" }), ": User输入 determines data size, linked lists (grow/shrink), trees (insert/delete nodes), reading files of unknown size, implementing resizable arrays."] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define static memory allocation and give one example." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Static memory allocation" }), " is the process where memory is allocated at compile time with a fixed size that cannot change during execution."] }), _jsxs(_components.p, { children: ["Example: ", _jsx(_components.code, { children: "int arr[100];" }), " allocates exactly 100 integers in memory."] })] })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Compare static and dynamic memory allocation." }), _jsxs(Answer, { children: [_jsx(ComparisonTable, { title: "Static vs Dynamic", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Aspect" }), _jsx(_components.th, { children: "Static" }), _jsx(_components.th, { children: "Dynamic" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Time" }), _jsx(_components.td, { children: "Compile time" }), _jsx(_components.td, { children: "Runtime" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Size" }), _jsx(_components.td, { children: "Fixed" }), _jsx(_components.td, { children: "Flexible" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Region" }), _jsx(_components.td, { children: "Stack" }), _jsx(_components.td, { children: "Heap" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Deallocation" }), _jsx(_components.td, { children: "Automatic" }), _jsx(_components.td, { children: "Manual (free)" })] })] })] }) }), _jsx(_components.p, { children: "Static allocation is faster but inflexible. Dynamic allocation allows resizing and is essential for structures like linked lists where the size changes during execution." })] })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain dynamic memory allocation in C with malloc and free, including a program example." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: ["Dynamic memory allocation in C uses functions from ", _jsx(_components.code, { children: "" }), ":"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "malloc(size)" }), ": Allocates ", _jsx(_components.code, { children: "size" }), " bytes of uninitialized memory."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "calloc(n, size)" }), ": Allocates memory for ", _jsx(_components.code, { children: "n" }), " elements, each of ", _jsx(_components.code, { children: "size" }), " bytes, initialized to zero."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "free(ptr)" }), ": Releases the allocated memory."] }), "\n"] }), _jsx(_components.p, { children: "Example program:" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: " #include \n #include \n\n int main() {\n int n, i;\n int *arr;\n scanf(\"%d\", &n);\n arr = (int *)malloc(n * sizeof(int));\n for (i = 0; i < n; i++)\n arr[i] = i * 10;\n for (i = 0; i < n; i++)\n printf(\"%d \", arr[i]);\n free(arr);\n return 0;\n }\n" }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["Always call ", _jsx(_components.code, { children: "free()" }), " after using malloc to prevent memory leaks. Never access memory after freeing it — this causes undefined behavior."] }) })] })] })] }) }), "\n", _jsxs(Assessment, { topicId: "3.1", children: [_jsx(MCQ, { questions: [{ "id": "3d8bf27a-4a57-4936-bb99-ddfbfa8a0276", "q": "In static memory allocation, memory is allocated at:", "options": ["Compile time", "Runtime only", "After program ends", "Never"], "answer": 0, "hint": "Static allocation happens before the program runs.", "explanation": "In static allocation, memory is allocated at compile time with a fixed size." }, { "id": "cf5867eb-b16b-4863-a420-3b6f017d143f", "q": "Dynamic memory allocation occurs at:", "options": ["Compile time", "Linking time", "Runtime", "Boot time"], "answer": 2, "hint": "Dynamic allocation happens when the program is running.", "explanation": "Dynamic memory is allocated during program execution (runtime)." }, { "id": "1eac46b9-da45-4705-b846-0eb80a6c041a", "q": "The malloc function allocates memory from:", "options": ["Stack", "Heap", "Register", "Cache"], "answer": 1, "hint": "malloc allocates from the heap.", "explanation": "malloc allocates memory from the heap region during runtime." }, { "id": "9045ca0e-1124-45dd-a325-4f733e4f7ec3", "q": "To release dynamically allocated memory in C, we use:", "options": ["delete", "remove", "close", "free"], "answer": 3, "hint": "We must free memory to prevent leaks.", "explanation": "free() releases dynamically allocated memory, preventing memory leaks." }, { "id": "0ddc538f-05cf-4c77-9fad-7c356261a47f", "q": "The stack memory follows which order?", "options": ["LIFO (Last In First Out)", "FIFO (First In First Out)", "Random", "Priority"], "answer": 0, "hint": "Stack follows Last In First Out.", "explanation": "The stack is a LIFO memory region used for static allocation and function calls." }, { "id": "c81c46d1-1cd3-4e81-aa24-38b72c6aab58", "q": "The main disadvantage of static allocation is:", "options": ["It is too slow", "The size cannot be changed during execution", "It needs free()", "It uses heap"], "answer": 1, "hint": "Static size cannot change during execution.", "explanation": "Static allocation has a fixed size determined at compile time." }, { "id": "ee65f485-92da-4638-8813-4d52baaec9a7", "q": "calloc differs from malloc because calloc:", "options": ["Is always faster", "Allocates on stack", "Initializes memory to zero", "Does not need free()"], "answer": 2, "hint": "calloc initializes memory to zero.", "explanation": "calloc allocates and initializes memory to zero, unlike malloc which leaves it uninitialized." }, { "id": "b837da2b-ff92-4837-af49-e785d9af51e2", "q": "Accessing memory after freeing it causes:", "options": ["Undefined behavior", "Faster execution", "Better performance", "Nothing"], "answer": 0, "hint": "Accessing freed memory is dangerous.", "explanation": "Accessing memory after freeing it causes undefined behavior (dangling pointer)." }, { "id": "119ffbba-040f-4278-97b1-16a8f7f647c1", "q": "Dynamic allocation is essential when:", "options": ["Data size is fixed", "Data size varies or is unknown", "Data is always 100 elements", "Data is only integers"], "answer": 1, "hint": "When data size is unknown, use dynamic allocation.", "explanation": "Dynamic allocation is essential when the data size varies or is not known in advance." }, { "id": "9a75b0ae-f837-4c94-adae-0aab5fc6349b", "q": "Linked lists require dynamic allocation because:", "options": ["Their size is always fixed", "They use only arrays", "They are stored on stack", "Their size changes during execution"], "answer": 3, "hint": "Linked lists need dynamic allocation because size changes.", "explanation": "Linked lists grow and shrink during execution, requiring dynamic memory allocation." }], topicId: "3.1" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Static vs Dynamic Memory Allocation", seoDesc: "Master Static vs Dynamic Memory Allocation with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "static vs dynamic memory allocation, static vs dynamic memory allocation notes, static vs dynamic memory allocation examples, diploma engineering notes, practice quiz, learningway" })] })] }); } 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."); }