Pointer arithmetic

📖 Theory

जो सवाल आधी class को गिरा देता है

एक int pointer p, address 5000 रखता है। p + 1 क्या है?

हर class के आधे लोग 5001 जवाब देते हैं, और mark गँवा देते हैं।

Machine का जवाब: 5004। क्योंकि p एक int* है, और एक int 4 bytes घेरता है, C ने तय किया कि pointer arithmetic को पूरे boxes में गिनना चाहिए, bytes में नहीं। यही एक design choice आज का lesson है, और यही वजह है कि pointers और arrays एक ही topic बनने वाले हैं।

📖 Theory

ईंटों के नहीं, घरों के आगे चलना

किसी गली में चलते हुए, "अगला घर" का मतलब "दाईं तरफ एक ईंट" नहीं होता: इसका मतलब है एक पूरा plot आगे, plot का size जो भी हो। Pointer arithmetic इसी तरह चलता है: p + 1 का मतलब p के type का अगला box है। Int के plot 4 bytes चौड़े हैं, char के 1, इसलिए वही +1 stride अलग-अलग दूरियाँ तय करता है। Pointer का type ही पर्ची पर plot का size है।

📖 Theory

Arithmetic, औपचारिक रूप से

एक pointer p, जिसका type T* है, और sizeof(T) = s:

• p + n → n boxes आगे का address: संख्या में p + n×s bytes।
• p - n → n boxes पीछे।
• p++ / p-- → एक box आगे/पीछे कदम (चलने वाला engine)।
• q - p (दोनों एक ही array में) → उनके बीच कितने ELEMENTS हैं, bytes नहीं।

बेमतलब और गैर-कानूनी: p + q (दो addresses जोड़ना कुछ जवाब नहीं देता), और pointers को गुणा या भाग करना। C ठीक वही operations देता है जो boxes की गली पर कोई मतलब रखते हैं।

⌨️ Practical

देखिए strides कैसे अलग हैं

#include <stdio.h>

int main() {
    int  marks[3] = {70, 80, 90};
    int  *p = &marks[0];
    char word[] = "abc";
    char *c = &word[0];

    printf("p   = %p\n", (void *)p);
    printf("p+1 = %p\n", (void *)(p + 1));   /* +4 bytes */
    printf("c   = %p\n", (void *)c);
    printf("c+1 = %p\n", (void *)(c + 1));   /* +1 byte  */
    printf("*(p+2) = %d\n", *(p + 2));
    return 0;
}

This example runs in Gri-Learn on the web, where you can edit it and see the output.

🧩 Quiz

एक float pointer pf, address 6000 रखता है (floats 4 bytes के होते हैं)। pf + 3 कौन सा address है?

1. 6012
2. 6003
3. 6004
4. 6300

💭 Think first

*(p + 2) को समझिए

ऊपर वाले code में, p, {70, 80, 90} के marks[0] को point करता है। दोनों operators के मतलब इस्तेमाल करके *(p + 2) को ज़ोर से पढ़िए, फिर अनुमान लगाइए कि यह क्या print करेगा।

🧩 Quiz

p, एक ही int array के marks[1] को point करता है और q, marks[4] को। q - p क्या है?

1. 3, उनके बीच elements की संख्या
2. 12, उनके बीच bytes की संख्या
3. 5, बड़ा index
4. गैर-कानूनी: pointers को घटाया नहीं जा सकता

⚠️ Watch out

Marks कहाँ कटते हैं

Byte गिनना: int पर p+1, 4 चलता है, 1 नहीं; हर जवाब में ×sizeof वाला step लिखिए। Pointers जोड़ना: p + q गैर-कानूनी है, सिर्फ अंतर मतलब रखते हैं। गली से बाहर चलना: array के अंत के आगे p++ out-of-bounds है, pointer वाले लहजे में, वही चुपचाप होने वाली corruption जो marks[n] में होती है। और (void ) cast के साथ %p, address PRINT करने का ईमानदार तरीका है, lab work में इस्तेमाल करने लायक।

📖 Theory

आगे का खुलासा

आपने reveal में पकड़ लिया: *(p + 2) ही marks[2] है। अगला lesson इसे official बनाता है: array का NAME, box zero का address है, indexing भेस बदले pointer arithmetic है, और scanf("%s", name) का & रहस्य हमेशा के लिए बंद हो जाता है। इस unit के दो सबसे बड़े idea हाथ मिलाने वाले हैं।

✅ Summary

Key takeaways

• Pointer arithmetic boxes में गिनता है: p + n, n × sizeof(type) bytes आगे बढ़ता है।
• int 5000 पर: p+1 है 5004; char 1 चलता है; float* 4।
• p++ box-दर-box चलता है, traversal engine।
• q - p (एक ही array) उनके बीच के ELEMENTS गिनता है; p + q गैर-कानूनी है।
• *(p + 2) दो boxes आगे की value उठाता है, और marks[2] के बराबर है।
• याद रखने का hook: अगला घर, अगली ईंट नहीं।