"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", span: "span", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, FormulaBox, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", 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 (!FormulaBox) _missingMdxReference("FormulaBox", true); if (!Hinglish) _missingMdxReference("Hinglish", 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: "5.6", title: "Pointers to Structure" }), _jsxs(TopicOverview, { title: "Pointers to Structure", topicId: "5.6", readingTime: "8 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["In C programming, a ", _jsx(_components.strong, { children: "pointer to a structure" }), " is a powerful tool that lets you indirectly access and manipulate the members of a structure variable by storing its memory address. Instead of working with the structure directly, you use a pointer to reach into its fields — read them, modify them, or pass them efficiently to functions. This becomes essential when you need to pass large structures to functions without copying, dynamically allocate structures at runtime, or manage arrays of structures efficiently. The ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") provides a clean and concise syntax for accessing structure members through a pointer, making your code both readable and performant. In this subtopic, we will explore how to declare, initialize, and use pointers to structures, including dynamic allocation and function parameter passing."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["C programming mein ", _jsx(_components.strong, { children: "pointer to structure" }), " ek bahut powerful concept hai jo tumhe structure ke members ko indirectly access aur modify karne deta hai — bas uska memory address store karo pointer mein aur pointer se uske fields tak pahunch jao. Structure ke saath directly kaam karne ki jagah, tum ek pointer use karke uske data ko read, modify, ya functions mein efficiently pass kar sakte ho. Yeh concept tab zaroori ho jaata hai jab tumhe bade structures ko bina copy kiye functions mein pass karna ho, runtime par dynamically allocate karna ho, ya structure arrays ko efficiently manage karna ho. C mein ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") tumhe pointer ke through structure members access karne ka clean aur concise syntax deta hai, jisse code readable aur performant dono rehta hai. Is subtopic mein hum dekhenge ki pointers to structures ko kaise declare, initialize aur use karte hain — saath mein dynamic allocation aur function parameter passing bhi cover karenge."] }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Pointer to Structure", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "pointer to a structure" }), " is a pointer variable that holds the memory address of a structure variable. Instead of storing a simple integer or character value, it stores the base address of an entire structure in memory. This allows you to access all members of the structure indirectly through the pointer, without creating copies. Imagine it like having the address of a building — you can send deliveries, send people, or renovate things inside without physically being at the building yourself."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Pointer to structure" }), " ek pointer variable hai jo kisi structure variable ka memory address store karta hai. Yeh koi simple integer ya character value nahi rakhta — yeh pure structure ka base address memory mein store karta hai. Isse tum pointer ke through structure ke saare members ko indirectly access kar sakte ho bina koi copy banaye. Isko aise samjho — jaise kisi building ka address ho tumhare paas — tum wahan deliveries bhej sakte ho, log bhej sakte ho, renovations kara sakte ho, bina physically building par jaaye."] }) })] }), _jsxs(DefinitionEntry, { term: "Arrow Operator (->\n\n)", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") is a special operator in C that combines the dereference operator (", _jsx(_components.code, { children: "*" }), ") and the dot operator (", _jsx(_components.code, { children: "." }), ") into one clean symbol. It is used exclusively with structure pointers to access their members. Writing ", _jsx(_components.code, { children: "ptr->rollNo" }), " is exactly the same as writing ", _jsx(_components.code, { children: "(*ptr).rollNo" }), ", but the arrow syntax is far more readable and is the standard way to access structure members through a pointer."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") C ka ek special operator hai jo dereference operator (", _jsx(_components.code, { children: "*" }), ") aur dot operator (", _jsx(_components.code, { children: "." }), ") ko ek clean symbol mein combine karta hai. Yeh sirf structure pointers ke saath use hota hai unke members access karne ke liye. ", _jsx(_components.code, { children: "ptr->rollNo" }), " likhna bilkul same hai jaise ", _jsx(_components.code, { children: "(*ptr).rollNo" }), " likhna, but arrow syntax zyada readable hai aur yeh structure pointers se members access karne ka standard way hai."] }) })] }), _jsxs(DefinitionEntry, { term: "Structure Pointer Parameter", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "structure pointer parameter" }), " is when a function accepts a pointer to a structure instead of receiving a complete copy of the structure. This is the most efficient way to pass structures to functions because it avoids the overhead of copying the entire structure. The function can directly read and modify the original structure's members. This is analogous to call by reference, where the function works with the original data, not a copy."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Structure pointer parameter" }), " tab hota hai jab kisi function ko structure ka pointer milta hai as a parameter — structure ki complete copy lene ki jagah. Yeh structures ko functions mein pass karne ka sabse efficient way hai kyunki pure structure ki copy banane ka overhead bach jaata hai. Function directly original structure ke members ko read aur modify kar sakta hai. Yeh basically call by reference jaisa hai, jisme function original data ke saath kaam karta hai, copy ke nahi."] }) })] })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "📦 Declaring and Initializing a Pointer to Structure" }), _jsxs(_components.p, { children: ["To create a pointer that points to a structure, you first need the structure definition, then declare a pointer of that structure type. The process is straightforward — use the structure name as the type, add the asterisk (", _jsx(_components.code, { children: "*" }), ") for the pointer, and assign the address of a structure variable using the address-of operator (", _jsx(_components.code, { children: "&" }), ")."] }), _jsxs(_components.p, { children: ["Consider a basic ", _jsx(_components.code, { children: "Student" }), " structure. When you write ", _jsx(_components.code, { children: "struct Student *ptr" }), ", you are telling the compiler to create a pointer that can hold the address of any ", _jsx(_components.code, { children: "struct Student" }), " variable. Then, ", _jsx(_components.code, { children: "ptr = &s1" }), " stores the address of ", _jsx(_components.code, { children: "s1" }), " in ", _jsx(_components.code, { children: "ptr" }), "."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📦 Structure Pointer Declare aur Initialize Karna" }), _jsxs(_components.p, { children: ["Ek pointer banana jo structure point kare, uske liye pehle tumhe structure definition chahiye, phir us structure type ka pointer declare karna hota hai. Process simple hai — structure name ko type karo, pointer ke liye asterisk (", _jsx(_components.code, { children: "*" }), ") lagao, aur address-of operator (", _jsx(_components.code, { children: "&" }), ") se structure variable ka address assign karo."] }), _jsxs(_components.p, { children: ["Ek basic ", _jsx(_components.code, { children: "Student" }), " structure lelo. Jab tum ", _jsx(_components.code, { children: "struct Student *ptr" }), " likhte ho, tum compiler ko bol rahe ho ki ek pointer banao jo kisi bhi ", _jsx(_components.code, { children: "struct Student" }), " variable ka address rakh sake. Phir ", _jsx(_components.code, { children: "ptr = &s1" }), " se ", _jsx(_components.code, { children: "s1" }), " ka address ", _jsx(_components.code, { children: "ptr" }), " mein store ho jaata hai."] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include struct Student { char name[50]; int rollNo; float marks; }; int main() { struct Student s1; strcpy(s1.name, "Ravi"); s1.rollNo = 101; s1.marks = 85.5; struct Student *ptr; // Declare pointer to structure ptr = &s1; // Initialize with address of s1 printf("Name: %s\\n", ptr->name); printf("Roll No: %d\\n", ptr->rollNo); printf("Marks: %.1f\\n", ptr->marks); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔗 Accessing Structure Members via Pointer — Arrow Operator" }), _jsxs(_components.p, { children: ["In C, there are two ways to access structure members through a pointer. The ", _jsx(_components.strong, { children: "dot operator" }), " (", _jsx(_components.code, { children: "." }), ") works directly with structure variables, while the ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") works with structure pointers. Both achieve the same result, but the arrow operator is the preferred and cleaner approach."] }), _jsx(_components.p, { children: "The key equivalence is:" })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔗 Pointer Se Structure Members Access Karna — Arrow Operator" }), _jsxs(_components.p, { children: ["C mein structure members ko pointer ke through access karne ke do tarike hain. ", _jsx(_components.strong, { children: "Dot operator" }), " (", _jsx(_components.code, { children: "." }), ") directly structure variables ke saath kaam karta hai, jabki ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") structure pointers ke saath kaam karta hai. Dono same result dete hain, but arrow operator zyada preferred aur clean hai."] }), _jsx(_components.p, { children: "Key equivalence yeh hai:" })] }), _jsx(FormulaBox, { title: "Arrow Operator Equivalence", children: _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8333em", verticalAlign: "-0.2222em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord texttt", children: "ptr->member" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "≡" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.9167em", verticalAlign: "-0.2222em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord texttt", children: "(*ptr).member" }) })] })] }) }) }) }), _jsx(CodeBlock, { language: "c", children: `#include #include struct Student { char name[50]; int rollNo; float marks; }; int main() { struct Student s1; strcpy(s1.name, "Anita"); s1.rollNo = 205; s1.marks = 92.0; struct Student *ptr = &s1; // Three ways to access the same member printf("Dot operator: %s\\n", s1.name); // Direct access printf("Arrow operator: %s\\n", ptr->name); // Via pointer (clean!) printf("Dereference way: %s\\n", (*ptr).name); // Verbose way // Modifying through pointer ptr->marks = 95.5; printf("Updated marks: %.1f\\n", s1.marks); // Output: 95.5 return 0; }` }), _jsx(English, { children: _jsxs(_components.p, { children: ["Notice that when we modified ", _jsx(_components.code, { children: "ptr->marks" }), ", the original ", _jsx(_components.code, { children: "s1.marks" }), " was updated. This confirms that ", _jsx(_components.code, { children: "ptr" }), " points to the same memory as ", _jsx(_components.code, { children: "s1" }), " — they are not separate copies."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Dekho, jab humne ", _jsx(_components.code, { children: "ptr->marks" }), " modify kiya, toh original ", _jsx(_components.code, { children: "s1.marks" }), " update ho gaya. Yeh confirm karta hai ki ", _jsx(_components.code, { children: "ptr" }), " aur ", _jsx(_components.code, { children: "s1" }), " same memory point karte hain — yeh alag copies nahi hain."] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🧠 How Pointer to Structure Works in Memory" }), _jsx(_components.p, { children: "When you declare a structure variable, memory is allocated to hold all its members contiguously. When you create a pointer and assign it the address of that structure, the pointer simply stores the starting address of that memory block. Accessing members through the pointer means going to that base address and offsetting to the correct member." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🧠 Pointer to Structure Memory Mein Kaise Kaam Karta Hai" }), _jsx(_components.p, { children: "Jab tum structure variable declare karte ho, toh memory allocate hoti hai jo uske saare members ko contiguously rakhe. Jab tum pointer banaate ho aur usse structure ka address assign karte ho, toh pointer bas us memory block ka starting address store karta hai. Pointer ke through members access karna matlab us base address par jaana aur sahi member tak offset karna." })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart LR\r\n ptr[\"struct Student *ptr
Stores Address: 0x1000\"] -->|\"points to\"| s1[\"s1 at Address 0x1000
name = 'Anita'
rollNo = 205
marks = 92.0\"]\r\n\r\n style ptr fill:#f9f,stroke:#333,stroke-width:2px\r\n style s1 fill:#bbf,stroke:#333,stroke-width:2px\n" }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📤 Passing Structure Pointers to Functions" }), _jsx(_components.p, { children: "One of the biggest advantages of using structure pointers is passing structures to functions efficiently. When you pass a structure by value, the entire structure is copied — which is wasteful for large structures. By passing a pointer instead, only the address is copied (typically 4 or 8 bytes), regardless of the structure's size." }), _jsxs(_components.p, { children: ["This is the ", _jsx(_components.strong, { children: "call by reference" }), " approach for structures. Inside the function, you use the arrow operator to access and modify the members."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📤 Structure Pointers Ko Functions Mein Pass Karna" }), _jsx(_components.p, { children: "Structure pointers use karne ka sabse bada advantage hai ki tum structures ko functions mein efficiently pass kar sakte ho. Jab tum structure by value pass karte ho, toh pura structure copy hota hai — jo bade structures ke liye bahut wasteful hai. Pointer pass karne se, sirf address copy hota hai (typically 4 ya 8 bytes), chahe structure kitna bhi bada ho." }), _jsxs(_components.p, { children: ["Yeh structures ke liye ", _jsx(_components.strong, { children: "call by reference" }), " approach hai. Function ke andar tum arrow operator use karke members access aur modify karte ho."] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include struct Student { char name[50]; int rollNo; float marks; }; // Function receives pointer to structure void displayStudent(struct Student *sp) { printf("Name: %s\\n", sp->name); printf("Roll No: %d\\n", sp->rollNo); printf("Marks: %.1f\\n", sp->marks); } // Function modifies structure through pointer void addBonus(struct Student *sp, float bonus) { sp->marks += bonus; printf("Bonus of %.1f added!\\n", bonus); } int main() { struct Student s1; strcpy(s1.name, "Vikram"); s1.rollNo = 312; s1.marks = 78.0; printf("Before bonus:\\n"); displayStudent(&s1); // Pass address of s1 addBonus(&s1, 10.0); // Modify through pointer printf("\\nAfter bonus:\\n"); displayStudent(&s1); return 0; }` }), _jsx(English, { children: _jsxs(_components.p, { children: ["Notice that we pass ", _jsx(_components.code, { children: "&s1" }), " (the address) to the functions, not ", _jsx(_components.code, { children: "s1" }), " itself. The function parameter ", _jsx(_components.code, { children: "struct Student *sp" }), " receives this address and uses the arrow operator to access the members."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Dekho, hum functions ko ", _jsx(_components.code, { children: "&s1" }), " (address) pass karte hain, ", _jsx(_components.code, { children: "s1" }), " khud nahi. Function parameter ", _jsx(_components.code, { children: "struct Student *sp" }), " yeh address receive karta hai aur arrow operator se members access karta hai."] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🧬 Dynamic Allocation of Structures" }), _jsxs(_components.p, { children: ["You can also create structures dynamically at runtime using ", _jsx(_components.code, { children: "malloc()" }), " or ", _jsx(_components.code, { children: "calloc()" }), ". This is especially useful when the number of structures needed is not known at compile time. After dynamic allocation, you access members using the arrow operator since ", _jsx(_components.code, { children: "malloc()" }), " returns a pointer."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🧬 Structures Ko Dynamically Allocate Karna" }), _jsxs(_components.p, { children: ["Tum runtime par ", _jsx(_components.code, { children: "malloc()" }), " ya ", _jsx(_components.code, { children: "calloc()" }), " se structures dynamically bhi bana sakte ho. Yeh tab bahut useful hota hai jab compile time par pata na ho ki kitne structures chahiye. Dynamic allocation ke baad, members access karne ke liye arrow operator use karo kyunki ", _jsx(_components.code, { children: "malloc()" }), " pointer return karta hai."] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include #include struct Student { char name[50]; int rollNo; float marks; }; int main() { // Dynamically allocate one structure struct Student *sp = (struct Student *)malloc(sizeof(struct Student)); if (sp == NULL) { printf("Memory allocation failed!\\n"); return 1; } strcpy(sp->name, "Priya"); sp->rollNo = 418; sp->marks = 88.5; printf("Name: %s\\n", sp->name); printf("Roll No: %d\\n", sp->rollNo); printf("Marks: %.1f\\n", sp->marks); free(sp); // Don't forget to free! return 0; }` }), _jsx(English, { children: _jsxs(_components.p, { children: ["When you dynamically allocate a structure, ", _jsx(_components.code, { children: "malloc()" }), " returns a pointer of type ", _jsx(_components.code, { children: "struct Student *" }), ". Since it is already a pointer, you use the arrow operator directly — no need for the dot operator. Always remember to ", _jsx(_components.code, { children: "free()" }), " the allocated memory when you are done."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Jab tum structure dynamically allocate karte ho, ", _jsx(_components.code, { children: "malloc()" }), " ", _jsx(_components.code, { children: "struct Student *" }), " type ka pointer return karta hai. Kyunki yeh already pointer hai, tum directly arrow operator use karte ho — dot operator ki zaroorat nahi. Aur haan, jab kaam ho jaaye toh allocated memory ko ", _jsx(_components.code, { children: "free()" }), " karna mat bhoolna!"] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📚 Array of Structure Pointers" }), _jsx(_components.p, { children: "An array of structure pointers is an array where each element is a pointer to a structure. This is extremely useful when you need to manage multiple structures — for example, storing records of many students. Instead of creating an array of structures (which copies all data), you can create an array of pointers that each point to a separate structure, giving you flexibility in sorting, filtering, and passing groups of structures." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📚 Structure Pointers Ka Array" }), _jsx(_components.p, { children: "Structure pointers ka array ek aisa array hai jisme har element ek structure pointer hota hai. Yeh tab bahut useful hota hai jab tumhe multiple structures manage karne ho — for example, bahut saare students ke records rakhne ho. Structure ka array banane ki jagah (jo saara data copy karta hai), tum pointers ka array bana sakte ho jisme har pointer alag structure ko point kare, jisse tumhe sorting, filtering, aur groups pass karne mein flexibility milti hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include #include #include struct Student { char name[50]; int rollNo; float marks; }; void printAll(struct Student *arr[], int n) { printf("--- Student Records ---\\n"); for (int i = 0; i < n; i++) { printf("%d. %s (Roll: %d, Marks: %.1f)\\n", i + 1, arr[i]->name, arr[i]->rollNo, arr[i]->marks); } } int main() { // Array of structure pointers struct Student *students[3]; // Dynamically allocate and assign for (int i = 0; i < 3; i++) { students[i] = (struct Student *)malloc(sizeof(struct Student)); } strcpy(students[0]->name, "Aman"); students[0]->rollNo = 101; students[0]->marks = 82.0; strcpy(students[1]->name, "Neha"); students[1]->rollNo = 102; students[1]->marks = 91.5; strcpy(students[2]->name, "Rohit"); students[2]->rollNo = 103; students[2]->marks = 76.0; printAll(students, 3); // Free all allocated memory for (int i = 0; i < 3; i++) { free(students[i]); } return 0; }` }), _jsx(English, { children: _jsxs(_components.p, { children: ["Here, ", _jsx(_components.code, { children: "students[i]->name" }), " accesses the ", _jsx(_components.code, { children: "name" }), " member of the structure pointed to by the i-th pointer in the array. Each element ", _jsx(_components.code, { children: "students[i]" }), " is itself a pointer, so the arrow operator is the correct way to access members."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yahan, ", _jsx(_components.code, { children: "students[i]->name" }), " us structure ka ", _jsx(_components.code, { children: "name" }), " member access karta hai jise i-th pointer point kar raha hai array mein. Har element ", _jsx(_components.code, { children: "students[i]" }), " khud ek pointer hai, toh members access karne ka sahi tarika arrow operator hai."] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔁 Returning a Structure Pointer from a Function" }), _jsxs(_components.p, { children: ["A function can also return a pointer to a structure. This is commonly used when you create a structure dynamically inside a function and want to pass it back to the caller. The function return type is ", _jsx(_components.code, { children: "struct TypeName *" }), " and you return the pointer."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔁 Function Se Structure Pointer Return Karna" }), _jsxs(_components.p, { children: ["Ek function structure pointer return bhi kar sakta hai. Yeh commonly tab use hota hai jab tum function ke andar structure dynamically create karte ho aur use caller ko wapas bhejna chahte ho. Function return type ", _jsx(_components.code, { children: "struct TypeName *" }), " hota hai aur tum pointer return karte ho."] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include #include struct Student { char name[50]; int rollNo; float marks; }; struct Student *createStudent(const char *name, int roll, float marks) { struct Student *newStu = (struct Student *)malloc(sizeof(struct Student)); if (newStu != NULL) { strcpy(newStu->name, name); newStu->rollNo = roll; newStu->marks = marks; } return newStu; } int main() { struct Student *s = createStudent("Kavya", 501, 94.0); if (s != NULL) { printf("Created: %s, Roll: %d, Marks: %.1f\\n", s->name, s->rollNo, s->marks); free(s); } return 0; }` }), _jsxs(Remember, { children: [_jsx(_components.h3, { children: "⚠️ Common Mistakes to Avoid" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Using ", _jsx(_components.code, { children: "." }), " with a pointer:"] }), " Writing ", _jsx(_components.code, { children: "ptr.name" }), " when ", _jsx(_components.code, { children: "ptr" }), " is a pointer will cause a compiler error. Always use ", _jsx(_components.code, { children: "ptr->name" }), " for pointers."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Using ", _jsx(_components.code, { children: "->" }), " with a structure variable:"] }), " Writing ", _jsx(_components.code, { children: "s1->name" }), " when ", _jsx(_components.code, { children: "s1" }), " is a regular structure variable (not a pointer) is wrong. Use ", _jsx(_components.code, { children: "s1.name" }), " for direct variables."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Forgetting to check for NULL:" }), " After ", _jsx(_components.code, { children: "malloc()" }), ", always check if the returned pointer is ", _jsx(_components.code, { children: "NULL" }), " before using it."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Memory leaks:" }), " If you dynamically allocate a structure, always ", _jsx(_components.code, { children: "free()" }), " it when done. Forgetting leads to memory leaks."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Returning pointer to local structure:" }), " Never return a pointer to a local (stack) structure variable — it becomes invalid once the function ends."] }), "\n"] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["A ", _jsx(_components.strong, { children: "pointer to a structure" }), " stores the memory address of a structure variable, allowing indirect access to all its members."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "arrow operator" }), " (", _jsx(_components.code, { children: "->" }), ") is used to access members through a structure pointer: ", _jsx(_components.code, { children: "ptr->member" }), " is equivalent to ", _jsx(_components.code, { children: "(*ptr).member" }), "."] }), "\n", _jsxs(_components.li, { children: ["Passing structure pointers to functions is the ", _jsx(_components.strong, { children: "efficient way" }), " to pass structures — it avoids copying the entire structure."] }), "\n", _jsxs(_components.li, { children: ["Structures can be ", _jsx(_components.strong, { children: "dynamically allocated" }), " using ", _jsx(_components.code, { children: "malloc()" }), " or ", _jsx(_components.code, { children: "calloc()" }), ", and members are accessed via the arrow operator."] }), "\n", _jsxs(_components.li, { children: ["An ", _jsx(_components.strong, { children: "array of structure pointers" }), " provides flexibility in managing multiple structures without copying data."] }), "\n", _jsxs(_components.li, { children: ["Always use ", _jsx(_components.code, { children: "free()" }), " for dynamically allocated structures to prevent memory leaks."] }), "\n", _jsx(_components.li, { children: "Never return a pointer to a local structure variable — it leads to undefined behavior." }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define a pointer to a structure and explain its purpose in C." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "pointer to a structure" }), " is a special type of pointer variable that stores the memory address of a structure variable. It is declared by placing an asterisk ", _jsx(_components.code, { children: "*" }), " before the pointer name and specifying the structure type it points to. Its primary purpose is to ", _jsx(_components.strong, { children: "efficiently access and manipulate structure members" }), " without having to copy the entire structure. Using a pointer avoids the overhead of passing large structures by value to functions, enabling ", _jsx(_components.strong, { children: "call by reference" }), " semantics for structures."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain how to declare a pointer to a structure, initialize it, and access its members using both the dot (.) and arrow (->) operators." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["📝 Declaration and Initialization 1. ", _jsx(_components.strong, { children: "Declare a structure:" }), " ", _jsx(_components.code, { children: "c struct Student { char name[50]; int roll; float marks; }; " }), " 2. ", _jsx(_components.strong, { children: "Declare a pointer to the structure and initialize it:" }), " ", _jsx(_components.code, { children: "c struct Student s1 = {"Amit", 101, 92.5}; struct Student *ptr; // Pointer declaration ptr = &s1; // Initialize with address of s1 " }), " Alternatively, in one line: ", _jsx(_components.code, { children: "struct Student *ptr = &s1;" }), " ### 🎯 Accessing Members When you have a structure variable (like ", _jsx(_components.code, { children: "s1" }), "), you use the ", _jsxs(_components.strong, { children: ["dot operator (", _jsx(_components.code, { children: "." }), ")"] }), ": ", _jsx(_components.code, { children: "s1.roll" }), " When you have a ", _jsx(_components.strong, { children: "pointer to a structure" }), " (like ", _jsx(_components.code, { children: "ptr" }), "), you use the ", _jsxs(_components.strong, { children: ["arrow operator (", _jsx(_components.code, { children: "->" }), ")"] }), ": ", _jsx(_components.code, { children: "ptr->roll" }), " The arrow operator ", _jsx(_components.code, { children: "->" }), " is essentially a shorthand. ", _jsx(_components.code, { children: "ptr->roll" }), " is equivalent to ", _jsx(_components.code, { children: "(*ptr).roll" }), ", where ", _jsx(_components.code, { children: "(*ptr)" }), " dereferences the pointer to get the structure instance, and then ", _jsx(_components.code, { children: "." }), " accesses the member. ", _jsx(_components.strong, { children: "Example Usage:" }), " ", _jsx(_components.code, { children: "c printf("Name: %s\\n", ptr->name); printf("Roll: %d\\n", ptr->roll); ptr->marks = 95.0; // Modifying member value via pointer " })] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a C program that uses a pointer to a structure. The program should: 1) Define a structure 'Employee' with fields name, id, and salary. 2) Allocate memory for one Employee using malloc. 3) Initialize its members through the pointer. 4) Pass the pointer to a function that displays the employee details. 5) Finally, free the allocated memory." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["Here is a complete C program demonstrating the use of pointers to structures, including dynamic memory allocation: ", `#include #include // For malloc and free // 1. Define the structure struct Employee { char name[50]; int id; float salary; }; // 4. Function to display employee details (takes a pointer) void displayEmployee(struct Employee *empPtr) { if (empPtr == NULL) { printf("Error: Invalid pointer!\\n"); return; } printf("\\n--- Employee Details ---\\n"); printf("Name: %s\\n", empPtr->name); // Using arrow operator printf("ID: %d\\n", empPtr->id); printf("Salary: %.2f\\n", empPtr->salary); } int main() { struct Employee *empPtr; // 2. Allocate memory for one Employee dynamically empPtr = (struct Employee *)malloc(sizeof(struct Employee)); if (empPtr == NULL) { printf("Memory allocation failed!\\n"); return 1; } // 3. Initialize members through the pointer printf("Enter Name: "); scanf("%s", empPtr->name); // empPtr->name is the array printf("Enter ID: "); scanf("%d", &empPtr->id); printf("Enter Salary: "); scanf("%f", &empPtr->salary); // 4. Pass the pointer to the display function displayEmployee(empPtr); // 5. Free the allocated memory free(empPtr); empPtr = NULL; // Good practice to avoid dangling pointer printf("\\nMemory freed successfully.\\n"); return 0; }`, " ", _jsx(_components.strong, { children: "Key Points in the Program:" }), " - ", _jsx(_components.strong, { children: "Dynamic Allocation:" }), " ", _jsx(_components.code, { children: "malloc(sizeof(struct Employee))" }), " allocates memory on the heap for one ", _jsx(_components.code, { children: "Employee" }), " structure and returns its address. - ", _jsxs(_components.strong, { children: ["Arrow Operator (", _jsx(_components.code, { children: "->" }), "):"] }), " Used consistently to access members of the structure via the pointer ", _jsx(_components.code, { children: "empPtr" }), " (e.g., ", _jsx(_components.code, { children: "empPtr->id" }), "). - ", _jsx(_components.strong, { children: "Pass by Reference:" }), " The function ", _jsx(_components.code, { children: "displayEmployee" }), " receives the address of the structure, allowing it to access and print the original data without creating a copy. - ", _jsx(_components.strong, { children: "Memory Management:" }), " ", _jsx(_components.code, { children: "free(empPtr)" }), " releases the dynamically allocated memory back to the system, preventing memory leaks."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "5.6", children: [_jsx(MCQ, { questions: [{ "id": "63c3922c-ffb9-4820-90c9-851d450399a1", "q": "Which operator is used to access members of a structure through a pointer to that structure?", "options": ["Dot operator (.)", "Ampersand operator (&)", "Arrow operator (->)", "Asterisk operator (*)"], "answer": 2, "hint": "The arrow operator is specifically designed for accessing structure members through a pointer.", "explanation": "The arrow operator is defined in C specifically for accessing structure members via a structure pointer. It combines dereferencing and member access into a single operator for convenience and readability." }, { "id": "42ddf087-2d6b-4b49-9692-610bd73dd64c", "q": "When a pointer to a structure is passed as a function argument, which parameter passing method is used?", "options": ["Call by value only", "Call by reference", "Call by name", "Call by result"], "answer": 1, "hint": "Consider what the pointer holds — an address, not a copy of the structure.", "explanation": "When a pointer to a structure is passed to a function, only the address of the structure is passed. No copy of the entire structure is created, making the function call efficient. This is equivalent to call by reference." }, { "id": "9c4001f0-c129-40f5-823e-0726d28dbdd0", "q": "Given struct S {"{"} int x; {"}"}; struct S s, *ptr = &s; which expression accesses member x of the structure?", "options": ["*ptr.x", "ptr.x", "&ptr.x", "(*ptr).x"], "answer": 3, "hint": "Think about the combination of dereferencing a pointer and then accessing a member using the dot operator.", "explanation": "The expression (*ptr).member first dereferences ptr to get the structure, then uses the dot operator to access the member. The parentheses around (*ptr) are necessary because the dot operator has higher precedence than the asterisk operator." }, { "id": "1134a5d2-7414-414b-a17f-e1583f2a4dfb", "q": "What does the expression ptr = (struct Student *)malloc(sizeof(struct Student)); assign to ptr?", "options": ["Base address of the dynamically allocated memory block", "Value of the first member of the structure", "Size of the structure in bytes", "Address of the malloc function"], "answer": 0, "hint": "Think about what malloc returns and how it relates to structure pointers.", "explanation": "The malloc function returns a void pointer which must be typecasted to the appropriate structure pointer type. This assigns a dynamically allocated block of memory to the structure pointer and returns its base address." }, { "id": "aaf1c145-4104-4e98-b7b2-d552bd952b4b", "q": "If ptr points to the first element of an array of structures, what is the effect of ptr = ptr + 1?", "options": ["Advances the pointer by 1 byte", "Advances the pointer by sizeof(int) bytes", "Advances the pointer by sizeof(struct) bytes", "Causes a compile-time error"], "answer": 2, "hint": "Consider how the compiler calculates the byte offset for each element in the array of structures.", "explanation": "For an array of structures, the pointer arithmetic automatically accounts for the size of each structure. Incrementing a structure pointer by 1 advances it by sizeof(struct) bytes, which is the size of one complete structure element in the array." }, { "id": "8ba30972-5025-4d2e-8eb9-1e6f07f0ff7e", "q": "Which expression is equivalent to ptr->name where ptr is a pointer to a structure?", "options": ["*ptr.name", "(*ptr).name", "&ptr.name", "ptr.*name"], "answer": 1, "hint": "The arrow operator is essentially shorthand for dereferencing then using the dot operator.", "explanation": "The arrow operator ptr->member is exactly equivalent to (*ptr).member. Both dereference the pointer to get the structure and then access the specified member. The arrow operator is simply a more convenient shorthand notation provided by the C language." }, { "id": "1395f659-1975-477b-a8bf-b0634316860e", "q": "Given struct S {"{"} int x; {"}"}; and struct S *ptr; which scanf statement correctly reads an integer into member x?", "options": ["scanf("%d", ptr->x);", "scanf("%d", ptr.x);", "scanf("%d", &ptr.x);", "scanf("%d", &(ptr->x));"], "answer": 3, "hint": "Remember that scanf needs the address of the variable to store input.", "explanation": "To read into member x of a structure via pointer ptr, we use &ptr->x. The arrow operator accesses the member first, and the ampersand takes its address for scanf to store the input value at the correct memory location." }, { "id": "57da5238-020a-4fca-996c-9ff63b5045ff", "q": "In the statement struct Emp *e = (struct Emp *)malloc(sizeof(struct Emp));, what is the role of sizeof(struct Emp)?", "options": ["It returns the address of the structure", "It initializes all members to zero", "It specifies the number of bytes to allocate", "It declares a new structure variable"], "answer": 2, "hint": "Think about what malloc needs — it must be told how many bytes to allocate using the sizeof operator.", "explanation": "The sizeof operator is used within malloc to determine how many bytes of memory to allocate for the structure. This ensures that the correct amount of memory is allocated regardless of the structure's size, making the code portable and less error-prone." }, { "id": "04cab33d-5589-40cb-a8e2-d9e42e19d26b", "q": "What is the difference between the expressions arr and &arr[0] when arr is a dynamically allocated array of structures?", "options": ["Both represent the base address of the array", "arr gives the size while &arr[0] gives the address", "arr points to the last element while &arr[0] points to the first", "They cause a compile-time error when compared"], "answer": 0, "hint": "Consider the difference between allocating one structure and an array of structures.", "explanation": "When malloc allocates space for an array of structures, the pointer returned points to the first element (the base address). Using the name of an array in C also evaluates to the address of its first element, making both expressions equivalent." }, { "id": "2153b245-8825-488f-9439-f7f832cebff0", "q": "Can a pointer to a structure store the address returned by malloc?", "options": ["No, because malloc returns data, not an address", "Yes, because malloc returns a memory address which the pointer can store", "No, because structure pointers can only point to stack variables", "Yes, but only after calling free() first"], "answer": 1, "hint": "Remember that in C, a pointer can hold the address of a dynamically allocated block, not just another variable.", "explanation": "A structure pointer can store the address returned by malloc because malloc allocates a block of memory and returns its base address as a void pointer. When cast to the appropriate structure pointer type, this address can be stored in ptr, allowing access to the dynamically allocated structure." }], topicId: "5.6" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Pointers to structure", seoDesc: "Master Pointers to structure with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "pointers to structure, pointers to structure notes, pointers to structure 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."); }