"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", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, 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 (!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 (!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.2", title: "Pointer arithmetic" }), _jsxs(TopicOverview, { title: "Understanding Pointer Arithmetic in C", topicId: "5.2", readingTime: "5 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsx(_components.p, { children: "Pointer arithmetic is one of the most powerful features of C that allows you to manipulate memory addresses directly. Unlike regular arithmetic, pointer arithmetic automatically adjusts operations based on the size of the data type the pointer points to. This makes it incredibly efficient for traversing arrays, working with dynamic memory, and building complex data structures. In this section, we will explore how incrementing, decrementing, adding, subtracting, and comparing pointers work, along with important rules and common pitfalls." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Pointer arithmetic C ki ek powerful feature hai jo aapko directly memory addresses manipulate karne ki capability deta hai. Regular arithmetic se different, pointer arithmetic automatically operations ko adjust karta hai based on the size of data type pointer point kar raha hai. Yeh arrays ko traverse karne, dynamic memory ke saath kaam karne aur complex data structures banane mein bahut efficient hai. Is section mein hum seekhenge ki increment, decrement, addition, subtraction aur comparison pointers ke saath kaise kaam karte hain, saath hi important rules aur common pitfalls ko bhi cover karenge." }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Pointer Arithmetic", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["Pointer arithmetic refers to arithmetic operations performed on pointer variables, such as increment (", _jsx(_components.code, { children: "++" }), "), decrement (", _jsx(_components.code, { children: "--" }), "), addition of an integer, subtraction of an integer, subtraction of two pointers (resulting in the number of elements between them), and relational comparisons. These operations are type-aware – the change in address is scaled by the size of the pointed-to data type."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Pointer arithmetic ka matlab hai pointer variables par arithmetic operations karna, jaise increment (", _jsx(_components.code, { children: "++" }), "), decrement (", _jsx(_components.code, { children: "--" }), "), integer add karna, integer subtract karna, do pointers ko subtract karna (jisse unke beech elements ka difference milta hai), aur relational comparisons. Ye operations type-aware hote hain – address mein change pointed-to data type ke size ke according scaled hota hai."] }) })] }), _jsxs(DefinitionEntry, { term: "Scale Factor", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The scale factor is the size (in bytes) of the data type that the pointer points to. For example, if ", _jsx(_components.code, { children: "p" }), " is an ", _jsx(_components.code, { children: "int*" }), ", then ", _jsx(_components.code, { children: "p + 1" }), " moves the address forward by ", _jsx(_components.code, { children: "sizeof(int)" }), " bytes (typically 4), not 1 byte. This automatic scaling ensures correct byte-level alignment when accessing array elements."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Scale factor pointer jis data type ko point kar raha hai us element ka size (bytes mein) hota hai. Example: agar ", _jsx(_components.code, { children: "p" }), " ", _jsx(_components.code, { children: "int*" }), " hai, to ", _jsx(_components.code, { children: "p + 1" }), " address ko ", _jsx(_components.code, { children: "sizeof(int)" }), " bytes (usually 4) aage badhata hai, 1 byte nahi. Ye automatic scaling ensure karta hai ki jab hum array elements access karein to byte-level alignment correct rahe."] }) })] }), _jsxs(DefinitionEntry, { term: "Pointer Subtraction", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["When two pointers of the same type point to elements within the same array, subtracting one from the other yields an integer of type ", _jsx(_components.code, { children: "ptrdiff_t" }), " representing the number of elements between them. For example, if ", _jsx(_components.code, { children: "p" }), " points to ", _jsx(_components.code, { children: "arr[2]" }), " and ", _jsx(_components.code, { children: "q" }), " points to ", _jsx(_components.code, { children: "arr[5]" }), ", then ", _jsx(_components.code, { children: "q - p" }), " gives 3."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Jab do pointers same type ke ho aur same array ke elements ko point kar rahe ho, to ek pointer ko doosre se subtract karne par ", _jsx(_components.code, { children: "ptrdiff_t" }), " type ka integer milta hai jo unke beech elements ki sankhya batata hai. Jaise agar ", _jsx(_components.code, { children: "p" }), " ", _jsx(_components.code, { children: "arr[2]" }), " point kare aur ", _jsx(_components.code, { children: "q" }), " ", _jsx(_components.code, { children: "arr[5]" }), " point kare, to ", _jsx(_components.code, { children: "q - p" }), " ka result 3 hoga."] }) })] }), _jsxs(DefinitionEntry, { term: "Pointer Comparison", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["Pointers pointing to elements of the same array can be compared using relational operators (", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<=" }), ", ", _jsx(_components.code, { children: ">=" }), ", ", _jsx(_components.code, { children: "==" }), ", ", _jsx(_components.code, { children: "!=" }), "). The result indicates the relative positions of the elements in memory (lower address comes before higher address in array order). This is often used in loops to traverse arrays."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Jo pointers same array ke elements ko point karte hain, unhe relational operators (", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<=" }), ", ", _jsx(_components.code, { children: ">=" }), ", ", _jsx(_components.code, { children: "==" }), ", ", _jsx(_components.code, { children: "!=" }), ") se compare kiya ja sakta hai. Result batata hai ki kaunsa element memory mein pehle hai (array order mein kam address pehle aata hai). Yeh aksar loops mein array traverse karne ke liye use hota hai."] }) })] })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🔍 What is Pointer Arithmetic?" }), _jsx(_components.p, { children: "Pointer arithmetic allows you to change the memory address a pointer holds using arithmetic operations. Because pointers store addresses (which are essentially integers), you can add or subtract integer values to move the pointer forward or backward." }), _jsxs(_components.p, { children: ["The key thing to remember is that pointer arithmetic is ", _jsx(_components.strong, { children: "scaled" }), ". When you do ", _jsx(_components.code, { children: "ptr + n" }), ", the compiler doesn't simply add ", _jsx(_components.code, { children: "n" }), " bytes to the address; instead, it adds ", _jsx(_components.code, { children: "n * sizeof(*ptr)" }), " bytes. This ensures that the pointer moves to the next ", _jsx(_components.strong, { children: "element" }), " of the array, not the next byte."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔍 Pointer Arithmetic Kya Hai?" }), _jsx(_components.p, { children: "Pointer arithmetic aapko pointer ke andar stored memory address ko arithmetic operations ke through change karne deta hai. Since pointers addresses store karte hain (jo essentially integers hote hain), aap integer values add ya subtract kar sakte hain pointer ko aage ya peeche move karne ke liye." }), _jsxs(_components.p, { children: ["Sabse important baat ye hai ki pointer arithmetic ", _jsx(_components.strong, { children: "scaled" }), " hota hai. Jab aap ", _jsx(_components.code, { children: "ptr + n" }), " karte hain, compiler sirf ", _jsx(_components.code, { children: "n" }), " bytes address mein nahi jodta; balki ", _jsx(_components.code, { children: "n * sizeof(*ptr)" }), " bytes add karta hai. Yeh ensure karta hai ki pointer array ke agle ", _jsx(_components.strong, { children: "element" }), " par pahuche, na ki agle byte par."] })] }), _jsx(ComparisonTable, { title: "Pointer Arithmetic vs Regular Integer Arithmetic", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operation" }), _jsx(_components.th, { children: "Regular Integer" }), _jsx(_components.th, { children: "Pointer (int* ptr)" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "+ 1" }), _jsx(_components.td, { children: "value becomes value+1" }), _jsx(_components.td, { children: "address increases by sizeof(int) bytes (usually 4)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "+ n" }), _jsx(_components.td, { children: "value becomes value+n" }), _jsx(_components.td, { children: "address increases by n * sizeof(int) bytes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "- n" }), _jsx(_components.td, { children: "value becomes value-n" }), _jsx(_components.td, { children: "address decreases by n * sizeof(int) bytes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "(ptr2 - ptr1)" }), _jsx(_components.td, { children: "—" }), _jsx(_components.td, { children: "gives number of ints between them (ptrdiff_t)" })] })] })] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "➕ Increment and Decrement Operators" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "++" }), " and ", _jsx(_components.code, { children: "--" }), " operators are the most commonly used pointer arithmetic operations."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr++" }), " moves the pointer to the next element (advances by ", _jsx(_components.code, { children: "sizeof(type)" }), " bytes)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr--" }), " moves the pointer to the previous element."] }), "\n"] }), _jsxs(_components.p, { children: ["For example, if ", _jsx(_components.code, { children: "int arr[] = {10, 20, 30};" }), " and ", _jsx(_components.code, { children: "int *p = arr;" }), " (pointing to ", _jsx(_components.code, { children: "arr[0]" }), "), after ", _jsx(_components.code, { children: "p++" }), ", ", _jsx(_components.code, { children: "p" }), " now points to ", _jsx(_components.code, { children: "arr[1]" }), " (address increased by 4 bytes)."] }), _jsx(_components.p, { children: "This is extremely useful for traversing arrays without using an index variable." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "➕ Increment aur Decrement Operators" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "++" }), " aur ", _jsx(_components.code, { children: "--" }), " operators sabse zyada use hone wale pointer arithmetic operations hain."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr++" }), " pointer ko next element par le jaata hai (address ", _jsx(_components.code, { children: "sizeof(type)" }), " bytes se badhta hai)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr--" }), " pointer ko previous element par le jaata hai."] }), "\n"] }), _jsxs(_components.p, { children: ["Example: agar ", _jsx(_components.code, { children: "int arr[] = {10, 20, 30};" }), " aur ", _jsx(_components.code, { children: "int *p = arr;" }), " (pointing to ", _jsx(_components.code, { children: "arr[0]" }), "), to ", _jsx(_components.code, { children: "p++" }), " ke baad ", _jsx(_components.code, { children: "p" }), " ", _jsx(_components.code, { children: "arr[1]" }), " ko point karega (address 4 bytes se badh gaya)."] }), _jsx(_components.p, { children: "Yeh array traversing mein index variable ke bina kaam aata hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int arr[] = {10, 20, 30, 40, 50}; int *ptr = arr; // points to arr[0] printf("Initial: %d (address: %p)\\n", *ptr, (void*)ptr); ptr++; // moves to arr[1] printf("After ptr++: %d (address: %p)\\n", *ptr, (void*)ptr); ptr += 2; // moves forward by 2 elements → arr[3] printf("After ptr+=2: %d (address: %p)\\n", *ptr, (void*)ptr); ptr--; // moves back to arr[2] printf("After ptr--: %d (address: %p)\\n", *ptr, (void*)ptr); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "➕ Addition and Subtraction of Integers" }), _jsxs(_components.p, { children: ["You can also add or subtract an integer ", _jsx(_components.code, { children: "n" }), " directly to a pointer:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr + n" }), " gives the address of the ", _jsx(_components.code, { children: "n" }), "-th element after ", _jsx(_components.code, { children: "ptr" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr - n" }), " gives the address of the ", _jsx(_components.code, { children: "n" }), "-th element before ", _jsx(_components.code, { children: "ptr" }), "."] }), "\n"] }), _jsxs(_components.p, { children: ["These operations do ", _jsx(_components.strong, { children: "not" }), " modify the original pointer; they return a new pointer value. To actually modify the pointer, you must use assignment: ", _jsx(_components.code, { children: "ptr = ptr + 2;" }), " or the compound assignment operator: ", _jsx(_components.code, { children: "ptr += 2;" }), "."] }), _jsxs(_components.p, { children: ["The expression ", _jsx(_components.code, { children: "*(ptr + n)" }), " is equivalent to ", _jsx(_components.code, { children: "ptr[n]" }), ". This shows the close relationship between arrays and pointers."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "➕ Integer Addition aur Subtraction" }), _jsxs(_components.p, { children: ["Aap pointer mein directly ek integer ", _jsx(_components.code, { children: "n" }), " add ya subtract kar sakte hain:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr + n" }), " pointer se ", _jsx(_components.code, { children: "n" }), " element aage ka address return karta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ptr - n" }), " pointer se ", _jsx(_components.code, { children: "n" }), " element peeche ka address return karta hai."] }), "\n"] }), _jsxs(_components.p, { children: ["Ye operations ", _jsx(_components.strong, { children: "original pointer ko modify nahi karte" }), "; ye ek naya pointer value return karte hain. Pointer ko actually modify karne ke liye assignment use karna hoga: ", _jsx(_components.code, { children: "ptr = ptr + 2;" }), " ya compound assignment: ", _jsx(_components.code, { children: "ptr += 2;" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "*(ptr + n)" }), " expression ", _jsx(_components.code, { children: "ptr[n]" }), " ke equivalent hota hai. Yahi array aur pointer ke beech ka close relationship dikhata hai."] })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart LR\r\n subgraph array[\"Array in Memory\"]\r\n direction LR\r\n A1[\"arr[0]
1000\"] --> A2[\"arr[1]
1004\"]\r\n A2 --> A3[\"arr[2]
1008\"]\r\n A3 --> A4[\"arr[3]
1012\"]\r\n A4 --> A5[\"arr[4]
1016\"]\r\n end\r\n P1[\"ptr initially
points here\"] -.-> A1\r\n P2[\"ptr after +1
points here\"] -.-> A2\r\n P3[\"ptr after +3
points here\"] -.-> A4\n" }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "➖ Subtraction of Two Pointers" }), _jsxs(_components.p, { children: ["When both pointers point to elements within the same array, subtracting one from the other gives the number of elements between them. The result is of type ", _jsx(_components.code, { children: "ptrdiff_t" }), " (defined in ", _jsx(_components.code, { children: "" }), "), which is a signed integer type."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Syntax:" }), " ", _jsx(_components.code, { children: "difference = pointer2 - pointer1;" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["If ", _jsx(_components.code, { children: "pointer2" }), " points to a later element, the result is positive."] }), "\n", _jsxs(_components.li, { children: ["If ", _jsx(_components.code, { children: "pointer2" }), " points to an earlier element, the result is negative."] }), "\n", _jsxs(_components.li, { children: ["Subtracting two pointers that do ", _jsx(_components.strong, { children: "not" }), " point to the same array is undefined behavior."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "➖ Do Pointers ka Subtraction" }), _jsxs(_components.p, { children: ["Jab dono pointers same array ke elements ko point kar rahe hote hain, to ek pointer ko doosre se subtract karne par unke beech elements ki sankhya milti hai. Result ", _jsx(_components.code, { children: "ptrdiff_t" }), " type ka hota hai (", _jsx(_components.code, { children: "" }), " mein defined), jo ek signed integer type hai."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Syntax:" }), " ", _jsx(_components.code, { children: "difference = pointer2 - pointer1;" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Agar ", _jsx(_components.code, { children: "pointer2" }), " aage wale element ko point kare, to result positive hoga."] }), "\n", _jsxs(_components.li, { children: ["Agar ", _jsx(_components.code, { children: "pointer2" }), " peeche wale element ko point kare, to result negative hoga."] }), "\n", _jsxs(_components.li, { children: ["Do pointers jo different arrays ko point karte hain, unka subtract karna ", _jsx(_components.strong, { children: "undefined behavior" }), " hai."] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int arr[] = {2, 4, 6, 8, 10}; int *p = &arr[1]; // points to arr[1] (value 4) int *q = &arr[4]; // points to arr[4] (value 10) ptrdiff_t diff = q - p; // number of elements between q and p printf("q - p = %td\\n", diff); // Output: 3 diff = p - q; // negative printf("p - q = %td\\n", diff); // Output: -3 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "⚖️ Pointer Comparison" }), _jsx(_components.p, { children: "Pointers pointing to the same array can be compared using relational operators:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p < q" }), " is true if ", _jsx(_components.code, { children: "p" }), " points to an earlier element than ", _jsx(_components.code, { children: "q" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p > q" }), " is true if ", _jsx(_components.code, { children: "p" }), " points to a later element."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p == q" }), " checks if both pointers point to the same element."] }), "\n"] }), _jsxs(_components.p, { children: ["Pointer comparison is often used to check boundaries while traversing an array (e.g., ", _jsx(_components.code, { children: "while(p < arr + size)" }), ")."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Important:" }), " Comparing pointers that do not belong to the same array (or one past the last element) is undefined behavior."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "⚖️ Pointer Comparison" }), _jsx(_components.p, { children: "Jo pointers same array ko point karte hain, unhe relational operators se compare kiya ja sakta hai:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p < q" }), " true hai agar ", _jsx(_components.code, { children: "p" }), " ", _jsx(_components.code, { children: "q" }), " se pehle wale element ko point kare."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p > q" }), " true hai agar ", _jsx(_components.code, { children: "p" }), " ", _jsx(_components.code, { children: "q" }), " se baad wale element ko point kare."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "p == q" }), " check karta hai ki dono pointers same element ko point karte hain ya nahi."] }), "\n"] }), _jsxs(_components.p, { children: ["Pointer comparison aksar array traverse karte waqt boundaries check karne mein use hota hai (jaise ", _jsx(_components.code, { children: "while(p < arr + size)" }), ")."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Important:" }), " Jo pointers same array ke nahi hain (ya array ke last element ke ek aage waale address ke) unka comparison undefined behavior hai."] })] }), _jsxs(Remember, { children: [_jsxs(English, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "Common Pitfalls with Pointer Arithmetic:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Adding two pointers (e.g. ", _jsx(_components.code, { children: "p + q" }), ") is ", _jsx(_components.strong, { children: "not allowed" }), " in C – it's meaningless."] }), "\n", _jsx(_components.li, { children: "Multiplication, division, and other arithmetic on pointers are also invalid." }), "\n", _jsx(_components.li, { children: "Subtracting pointers from different arrays leads to undefined behavior." }), "\n", _jsx(_components.li, { children: "Dereferencing a pointer that has been moved beyond the array bounds (except one past the last) is dangerous." }), "\n", _jsx(_components.li, { children: "Always ensure pointer arithmetic stays within the allocated memory range." }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "Pointer Arithmetic ke Common Pitfalls:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Do pointers ko add karna (jaise ", _jsx(_components.code, { children: "p + q" }), ") ", _jsx(_components.strong, { children: "allowed nahi hai" }), " C mein – iska koi meaning nahi hai."] }), "\n", _jsx(_components.li, { children: "Multiplication, division, aur doosre arithmetic operations bhi invalid hain." }), "\n", _jsx(_components.li, { children: "Different arrays ke pointers subtract karna undefined behavior hai." }), "\n", _jsx(_components.li, { children: "Array ki bounds ke bahar chale gaye pointer ko dereference karna (last element ke ek aage waale ko chhodkar) dangerous hai." }), "\n", _jsx(_components.li, { children: "Hamesha ensure karein ki pointer arithmetic allocated memory range ke andar rahe." }), "\n"] })] })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 When is Pointer Arithmetic Useful?" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Array traversal:" }), " Using ", _jsx(_components.code, { children: "ptr++" }), " in loops to visit each element without an index."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dynamic memory:" }), " Manipulating allocated blocks (e.g., moving through memory chunks in linked lists or custom allocators)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Buffer handling:" }), " In systems programming, pointer arithmetic is essential for reading/writing data buffers."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Array indexing equivalence:" }), " ", _jsx(_components.code, { children: "arr[i]" }), " is equivalent to ", _jsx(_components.code, { children: "*(arr + i)" }), ", so understanding pointer arithmetic deepens your grasp of arrays."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Pointer Arithmetic Kab Useful Hai?" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Array traversal:" }), " Bina index ke loop mein ", _jsx(_components.code, { children: "ptr++" }), " use karke har element visit karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dynamic memory:" }), " Allocated blocks ko manipulate karna (jaise linked lists ya custom allocators mein memory chunks ke beech move karna)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Buffer handling:" }), " Systems programming mein, pointer arithmetic data buffers read/write karne ke liye zaroori hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Array indexing equivalence:" }), " ", _jsx(_components.code, { children: "arr[i]" }), " ", _jsx(_components.code, { children: "*(arr + i)" }), " ke equivalent hai, isliye pointer arithmetic samajhne se arrays ki deeper understanding milti hai."] }), "\n"] })] }), _jsxs(KeyPoints, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Pointer arithmetic is scaled: ", _jsx(_components.code, { children: "ptr + n" }), " adds ", _jsx(_components.code, { children: "n * sizeof(*ptr)" }), " bytes to the address.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Supported operations: ", _jsx(_components.code, { children: "++" }), ", ", _jsx(_components.code, { children: "--" }), ", ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), " (with integer), subtraction of two pointers (gives element count), and comparison (within same array)."] }), "\n", _jsx(_components.li, { children: "Adding two pointers or performing multiplication/division on pointers is invalid." }), "\n", _jsx(_components.li, { children: "Subtracting pointers from different arrays is undefined behavior." }), "\n", _jsx(_components.li, { children: "Pointer comparison is valid only for pointers to the same array (or one past the end)." }), "\n"] }), "\n"] }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Pointer arithmetic scaled hota hai: ", _jsx(_components.code, { children: "ptr + n" }), " address mein ", _jsx(_components.code, { children: "n * sizeof(*ptr)" }), " bytes add karta hai.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Supported operations: ", _jsx(_components.code, { children: "++" }), ", ", _jsx(_components.code, { children: "--" }), ", ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), " (integer ke saath), do pointers ka subtraction (element count deta hai), aur comparison (same array ke andar)."] }), "\n", _jsx(_components.li, { children: "Do pointers ka add karna ya multiplication/division karna invalid hai." }), "\n", _jsx(_components.li, { children: "Different arrays ke pointers subtract karna undefined behavior hai." }), "\n", _jsx(_components.li, { children: "Pointer comparison sirf same array (ya last element ke ek aage) pointers ke liye valid hai." }), "\n"] }), "\n"] }), "\n"] }) })] })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define pointer arithmetic and list the valid arithmetic operations that can be performed on pointers." }), _jsx(Answer, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Pointer arithmetic" }), " is the capability to perform arithmetic operations on pointer variables, where the size of the data type is automatically considered. Valid pointer arithmetic operations: - Increment (", _jsx(_components.code, { children: "ptr++" }), "): Moves the pointer to the next element. - Decrement (", _jsx(_components.code, { children: "ptr--" }), "): Moves the pointer to the previous element. - Addition of integer (", _jsx(_components.code, { children: "ptr + n" }), "): Advances the pointer by ", _jsx(_components.code, { children: "n" }), " elements. - Subtraction of integer (", _jsx(_components.code, { children: "ptr - n" }), "): Moves the pointer back by ", _jsx(_components.code, { children: "n" }), " elements. - Difference (", _jsx(_components.code, { children: "ptr1 - ptr2" }), "): Returns the number of elements between the two pointers (requires same array). - Comparison (", _jsx(_components.code, { children: "==" }), ", ", _jsx(_components.code, { children: "!=" }), ", ", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<=" }), ", ", _jsx(_components.code, { children: ">=" }), "): Compares memory addresses."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain the effect of increment operation on a pointer pointing to different data types (int, float, char) with an example. Show how the address stored in the pointer changes." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["When a pointer is incremented, the address stored increases by the size of the data type it points to. For example, if an ", _jsx(_components.code, { children: "int" }), " pointer initially holds address 1000, after ", _jsx(_components.code, { children: "ptr++" }), " it becomes 1004 (assuming ", _jsx(_components.code, { children: "sizeof(int)=4" }), "). This scaling ensures the pointer moves to the exact next element of its type. The table below summarizes the address change for common data types: | Data Type | Size (bytes) | Address increment on ", _jsx(_components.code, { children: "ptr++" }), " | |-----------|--------------|------------------------------| | ", _jsx(_components.code, { children: "int" }), " | 4 | +4 bytes | | ", _jsx(_components.code, { children: "float" }), " | 4 | +4 bytes | | ", _jsx(_components.code, { children: "char" }), " | 1 | +1 byte | | ", _jsx(_components.code, { children: "double" }), " | 8 | +8 bytes | Example: ", _jsx(_components.code, { children: "c int a = 10; int *p = &a; printf("Before: %p\\n", (void*)p); p++; printf("After: %p\\n", (void*)p); " })] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a C program to demonstrate all pointer arithmetic operations on a one-dimensional integer array: increment, decrement, addition of integer, subtraction of integer, and difference between two pointers. Show the address and value after each operation." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["Program ", _jsx(_components.code, { children: "c #include int main() { int arr[] = {10, 20, 30, 40, 50}; int *ptr1 = &arr[0]; int *ptr2 = &arr[4]; // Initial state printf("Initial: ptr1 = %p, *ptr1 = %d\\n", (void*)ptr1, *ptr1); printf("Initial: ptr2 = %p, *ptr2 = %d\\n", (void*)ptr2, *ptr2); // Increment ptr1++; printf("After ptr1++: ptr1 = %p, *ptr1 = %d\\n", (void*)ptr1, *ptr1); // Decrement ptr2--; printf("After ptr2--: ptr2 = %p, *ptr2 = %d\\n", (void*)ptr2, *ptr2); // Addition of integer ptr1 = ptr1 + 2; // now points to arr[3] printf("After ptr1+2: ptr1 = %p, *ptr1 = %d\\n", (void*)ptr1, *ptr1); // Subtraction of integer ptr2 = ptr2 - 1; // points to arr[2] printf("After ptr2-1: ptr2 = %p, *ptr2 = %d\\n", (void*)ptr2, *ptr2); // Difference int diff = ptr1 - ptr2; printf("Difference (ptr1-ptr2): %d elements\\n", diff); // Comparison if (ptr1 > ptr2) printf("ptr1 > ptr2\\n"); else printf("ptr1 <= ptr2\\n"); return 0; } " }), " ### Output Explanation The actual addresses will differ, but the relative movement is fixed: each increment/decrement changes the address by ", _jsx(_components.code, { children: "sizeof(int)" }), " bytes. After ", _jsx(_components.code, { children: "ptr1++" }), ", it moves from arr[0] to arr[1]; after ", _jsx(_components.code, { children: "ptr2--" }), ", from arr[4] to arr[3]. Adding 2 to ptr1 moves it to arr[3]; subtracting 1 from ptr2 moves it to arr[2]. The difference ", _jsx(_components.code, { children: "ptr1 - ptr2" }), " equals 1 (number of elements between arr[3] and arr[2]). The comparison shows ", _jsx(_components.code, { children: "ptr1 > ptr2" }), " as arr[3] is at a higher address than arr[2]. Pointer arithmetic automatically scales by the size of the pointed type. For ", _jsx(_components.code, { children: "int" }), " arrays, each step moves by ", _jsx(_components.code, { children: "sizeof(int)" }), " bytes."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "5.2", children: [_jsx(MCQ, { questions: [{ "id": "01c9b2a0-0338-44b4-91c1-e271702a0061", "q": "If `int *p = (int*)1000`, what is the value of `p+1` (assuming `sizeof(int) == 4`)?", "options": ["1001", "1004", "1000", "1008"], "answer": 1, "hint": "Consider the size of data type pointed to.", "explanation": "Pointers are incremented by the size of the type they point to. For int (usually 4 bytes), p+1 moves by 4 bytes." }, { "id": "83fb5a2a-7842-45c3-a110-403388121df1", "q": "If `int a[5] = {0}; int *p = &a[2]; int *q = &a[4];`, what is `q - p`?", "options": ["8", "4", "2", "1"], "answer": 2, "hint": "Pointer subtraction gives the number of elements between them.", "explanation": "Subtracting two pointers of same type (pointing to same array) returns the difference in index (number of elements). (b - a) = (1000-996)/4 = 1." }, { "id": "8910eb14-a4a3-440a-ae08-4ba12758123f", "q": "What is the result of comparing two pointers that point to different arrays using the `>` operator?", "options": ["Undefined behavior", "Always zero (false)", "Always non-zero (true)", "Compilation error"], "answer": 0, "hint": "Comparing pointers using relational operators between different arrays is undefined.", "explanation": "C standard does not guarantee the result when comparing pointers to different arrays (or different objects). It's undefined behavior." }, { "id": "7aea68b3-7dee-4a87-be49-a694b6742858", "q": "Which of the following is true about pointer arithmetic on a `void*` pointer in standard C?", "options": ["Arithmetic is allowed and increments by 1 byte", "Arithmetic is allowed and increments by 4 bytes", "Arithmetic is not allowed; it results in compilation error", "Arithmetic is allowed but only subtraction"], "answer": 2, "hint": "Pointer arithmetic requires complete type size.", "explanation": "In standard C, arithmetic on void pointers is not allowed because void is incomplete type. Some compilers may allow it as a GNU extension treating size as 1." }, { "id": "7c7f2cbc-9e44-4839-9a14-65d0c71ff2a1", "q": "If `char *p = "Hello"; p++` moves the pointer by how many bytes?", "options": ["1", "2", "4", "Depends on compiler"], "answer": 0, "hint": "A character pointer increments by 1 byte.", "explanation": "char has size 1, so incrementing a char pointer moves to next byte." }, { "id": "5a600521-ebf8-44bc-94cf-058ae7bd900d", "q": "If `int a[5] = {10,20,30,40,50}; int *p = &a[3]; --p; printf("%d",*p);` What is output?", "options": ["40", "30", "20", "10"], "answer": 1, "hint": "Pre-decrement changes pointer before using its value.", "explanation": "--p first decrements p by 1 element, then returns the new pointer. p originally points to a[3], after decrement points to a[2]." }, { "id": "abf76c38-a379-4301-aa55-7d57daa0016e", "q": "If `int x; int *p = &x;` and `&x` is 2000, `sizeof(int)=4`. What is `&x + 2`?", "options": ["2008", "2002", "2004", "2016"], "answer": 0, "hint": "When adding integer to pointer, the result is scaled by object size.", "explanation": "p+n moves forward by n*sizeof(int) bytes. p+2 would be 1000+8=1008." }, { "id": "f2542c8e-1e09-404a-a716-ead7d15734cd", "q": "Pointer subtraction is valid only when both pointers point to:", "options": ["Different arrays", "Same data type", "Same array", "Same array or one past the last element"], "answer": 3, "hint": "Difference between two pointers gives number of elements only if they point into the same array.", "explanation": "The rule applies only when both pointers point into the same array object (or one past the last). Otherwise subtract is undefined." }, { "id": "790a7cc6-db55-4e17-93d6-4ba46a7ac81a", "q": "If `int a[5] = {1,2,3,4,5}; int *p = &a[2];` what does the expression `p--` evaluate to?", "options": ["Address of a[1]", "Address of a[2]", "Address of a[3]", "Value of a[2]"], "answer": 1, "hint": "Post-decrement uses current value then decrements.", "explanation": "p-- returns current pointer value (address of a[2]) then decreases p by 1 element (to a[1]). So the expression value is address of a[2]." }, { "id": "9f229bfe-a809-4edf-b2e4-ae387dbcf133", "q": "If `int a[5] = {10,20,30,40,50};` what is `*(a+3)`?", "options": ["20", "30", "40", "50"], "answer": 2, "hint": "Array name is a constant pointer to first element.", "explanation": "a is pointer to first element. a+3 points to a[3], which is the 4th element. * (a+3) equals a[3]." }], topicId: "5.2" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Pointer arithmetic", seoDesc: "Master Pointer arithmetic with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "pointer arithmetic, pointer arithmetic notes, pointer arithmetic 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."); }