Lesson 10 — Intermediate

Pointers in C

Pointer C ki pehchaan hai — ye variable ka ADDRESS rakhta hai, value nahi. Is samajh se arrays, strings, memory aur functions ka asli khel khulta hai. Is lesson mein hum pointer ki bhasha samjhenge, swap wale classic se pass by reference dekhenge, aur wo galtiyan bhi jo crash laati hain.

Pointer kya hai — & aur *

#include <stdio.h>
int main() {
    int x = 10;
    int *p = &x;          // p mein x ka address

    printf("x = %d\n", x);     // 10
    printf("*p = %d\n", *p);   // 10 (address se value)
    printf("p = %p\n", p);     // 0x7ffd... (address)

    *p = 25;              // x badal diya (dereference se)
    printf("x = %d\n", x);     // 25
    return 0;
}

Output:
x = 10
*p = 10
p = 0x7ffd4a2b
x = 25

• & (address-of): variable ki memory location nikaalta hai.
• * (dereference): address mein jo pada hai woh value — aur *p = value likhne se asli variable badal jaata hai.
• Type matter karta hai: int *p sirf int address rakhega — type mismatch = warning/error.
• Declaration mein * batata hai ki ye pointer hai; use karte waqt * matlab dereference.

Pointer arithmetic aur arrays

#include <stdio.h>
int main() {
    int a[5] = {10, 20, 30, 40, 50};
    int *p = a;              // array = uska base address

    printf("%d\n", *p);        // 10
    printf("%d\n", *(p + 2));  // 30 (do element aage)

    p++;
    printf("%d\n", *p);        // 20 (4 byte aage — int ka size)
    return 0;
}

Output:
10
30
20

Pointer badhne ka matlab hai apne type ke size se utne bytes aage. int *++ = 4 bytes, char *++ = 1 byte, double *++ = 8 bytes. p + 2 ka matlab p se 2 elements aage — 2 bytes nahi!

Pass by reference — swap ka classic

#include <stdio.h>

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int main() {
    int x = 5, y = 9;
    swap(&x, &y);            // ADDRESS bheja
    printf("%d %d\n", x, y); // 9 5 — badal gaya!
    return 0;
}

Output: 9 5

Yahi hai call by reference ka C wala jugaad: function ko address do (&x), andar se *se value pakdo. Function apne pointers ki madad se asli variables tak pahunch jaata hai.

swap(&x, &y) ka flow:
Call : a = &x, b = &y (dono pointers mein addresses)
*a   : x ki value (5)
*a = *b : x = 9
*b = t  : y = 5
Result : x = 9, y = 5  ✓

Bina & ke (swap(x, y)) : sirf copies — kuch nahi badlega

NULL, dangling aur pointer traps

// 1. Uninitialized pointer — garbage
int *p;         // kisi ka address nahi — abhi random
// *p = 5;      // CRASH/silently memory kharab!

// 2. NULL se safe rehna
int *p = NULL;          // kisi object ka address nahi
if (p != NULL) *p = 5;  // safe check

// 3. Pointer to pointer
int x = 5;
int *p = &x;
int **pp = &p;
printf("%d\n", **pp);    // 5 — do level dereference

• NULL pointer: kisi valid memory ka address nahi — NULL deref = crash (segmentation fault).
• Dangling pointer: memory chali gayi (function return, free) par pointer pada hai — use karne se garbage/crash.
• Double free: ek block do baar free = heap corruption. Free ke baad pointer NULL kar do.
• Uninitialized pointer: garbage address — hamesha NULL ya valid address se shuru karo.
• void *: kisi bhi type ka address rakh sakta hai (malloc isi se return karta hai) — par use se pehle cast chahiye.

Exercise

Common mistakes

• Bina dereference kiye value badalne ki koshish: p = 5 likhne se POINTER ki value (address) badlega, x nahi. Asli x ke liye *p = 5 — star zaroori hai.
• NULL pointer ko chhod dena: malloc fail, fopen fail — aise pointers NULL hote hain. Check kiye bina deref = crash. Hamesha if (p != NULL).
• Freed memory ka pointer use karna: free(p) ke baad *p = garbage/dangling. Free ke turant baad p = NULL kar do — habit banao.

x = ghar (value = 10)
p = x ka address (jaise "42, Gandhi Nagar")
*p = ghar ke andar jaakar samaan badalna

&x = "kahan hai ghar?"  → address
*p = "andar kya hai?"   → value

swap(x, y)      = bina address bheje — kuch nahi hua
swap(&x, &y)    = address bheja — kaam ho gaya