Visual walkthrough — Typedef

5.1.26 · D2 · Coding › C Programming › Typedef

Step 1 — Ek plain declaration asal mein kya kehti hai

KYA. C ki sabse simple possible line se shuru karte hain:

int x;

YAHAAN SE KYUN SHURU KAREIN. typedef bilkul isi shape ko copy karta hai. Agar hum samajh lein ki aankh aur compiler ek variable declaration ko kaise padhte hain, toh hume typedef free mein mil jaata hai — kyunki typedef literally yahi line hai jisme ek word aage jod diya gaya hai.

PICTURE. C mein ek declaration ke do kaam hote hain jo do jagahon pe pin hote hain. Left pe hota hai base type (int). Middle mein hota hai naam jo introduce ho raha hai (x). Isse ek sentence ki tarah padho:

$\underset{\text{the type}}{\underbrace{\text{int}}}\underset{\text{the name}}{\underbrace{\text{x}}}\text{;}$

• int — cheez ki qisam.
• x — woh label jisse hum us qisam ki cheez ko refer kar sakte hain.

Step 2 — Aage typedef jod do

KYA. Usi line ke aage keyword typedef lagao:

typedef int Integer;

KYUN. C designers ne ek jaanbujhkar choice ki: aliases ke liye bilkul naya syntax invent karne ki bajaye, unhone wahi declaration syntax reuse kiya jo aap jaante the. Unka add kiya hua ek hi rule hai — ek meaning ka flip, jo aage dikhega.

PICTURE. Har cheez Step 1 jaisi hi lagti hai, sirf ek word dum left mein aa gaya hai:

$\underset{\text{"name slot ab ek TYPE hai"}}{\underbrace{\text{typedef}}}\underset{\text{base type}}{\underbrace{\text{int}}}\underset{\text{name slot}}{\underbrace{\text{Integer}}}\text{;}$

• typedef — ek switch. Yeh compiler ko kehta hai: "variable mat banao; balki, name slot mein jo bhi naam baitha hai woh ek type ka naya naam ban jaata hai."
• int — abhi bhi base type hai.
• Integer — name slot mein baitha hai. Toh Integer ab int ka alias hai.

Step 3 — * naam ke saath kyun chipakta hai, type ke saath nahin

KYA. Ab ek pointer wali line:

char *String;   // without typedef

KYUN YEH MATTER KARTA HAI. Yeh C declarations ki sabse tricky cheez hai, aur saari "pointer typedef surprise" isi se aati hai. Koi bhi pointer alias trust karne se pehle hume yeh dekhna padega ki * kahan bind karta hai.

PICTURE. * base type char ka hissa nahin hai. Yeh naam String ke saath juda hai. Declaration ko is tarah padho: "*String ek char hai", yaani "jab String ko dereference karo toh char milta hai", yaani String ek pointer-to-char hai.

$\text{char}\underset{\begin{array}{c}\text{"ise dereference karne par}\\ \text{char milta hai"}\end{array}}{\underbrace{\text{*String}}}\text{;}\Rightarrow \text{String : pointer-to-char}$

• char — base type (jo pointer follow karne ke baad milta hai).
• * — naam ke saath bind hota hai, matlab "pointer to..."।
• String — naam.

Step 4 — Pointer line mein typedef add karo

KYA.

typedef char *String;

KYUN. Steps 2 aur 3 ko saath apply karo. typedef aage lagao; name slot ka identifier String hai; us identifier ka type kya hota — "pointer to char". Toh String char * ka alias ban jaata hai.

PICTURE. Step 3 jaisa hi layout, bas switch flip ho gaya:

$\underset{\text{switch on}}{\underbrace{\text{typedef}}}\text{char}\underset{\text{name slot = "ptr to char"}}{\underbrace{\text{*String}}}\text{;}\Rightarrow \text{String}\equiv \text{char *}$

Kyunki * Step 3 mein alias ke andar bake tha, ab yeh us type ka hissa hai jisko String naam karta hai. Yahi Step 5 ki famous surprise ka beej hai.

Step 5 — Multi-name surprise (edge case)

KYA. Pointer alias ke saath aur raw * ke saath do naam declare karo:

typedef int* IntPtr;
IntPtr  a, b;   // a: int*   b: int*   (DONO pointers)
 
int*    c, d;   // c: int*   d: int    (sirf c!)

KYUN DIKHAYEIN. Yeh woh degenerate case hai jahan beginners burn hote hain. Hume prove karna hai ki results alag kyun hote hain — aur jawab poora Step 3 se aata hai.

PICTURE. int* c, d; mein * sirf pehle naam (c) ke saath bind hota hai; d sirf base type int reuse karta hai. Lekin IntPtr ek poora type hai — * already uske andar hai — toh list mein har naam complete pointer type inherit karta hai.

$\begin{array}{ll}\text{int}\stackrel{\downarrow }{\ast }\text{c},\text{d}& \Rightarrow c:\text{int*},d:\text{int}\\ \text{IntPtr}\text{a},\text{b}& \Rightarrow a:\text{int*},b:\text{int*}\end{array}$

• upar wali line: arrow dikhata hai * sirf c tak pahunch raha hai.
• neeche wali line: koi loose * nahin hai — pointerness IntPtr ke andar rehti hai, toh a aur b dono full pointers hain.

Step 6 — struct case: ek keyword hataana

KYA.

struct Point { int x, y; };
typedef struct Point Point;   // 'struct Point' ke liye alias 'Point'
Point p;                      // 'struct Point p;' ki jagah

KYUN. C mein, struct tags ek alag namespace mein rehte hain, isliye poora type naam do words ka hota hai: struct Point. Apna rule apply karo: typedef hatao → struct Point Point; ek variable Point declare karta hai jo struct Point type ka hai. Toh alias Point ab struct Point matlab hai, aur hum keyword hamesha ke liye drop kar sakte hain.

PICTURE. Do namespaces side by side baithte hain; typedef plain naam Point (type namespace) se tagged type struct Point tak ek bridge banata hai.

$\underset{\text{tag namespace, 2 words}}{\underbrace{\text{struct Point}}}\stackrel{\text{typedef}}{\to }\underset{\text{type namespace, 1 word}}{\underbrace{\text{Point}}}$

Step 7 — Boss level: ek function-pointer typedef

KYA. Sabse common ugly form decode karo:

typedef int (*Operation)(int, int);

KYUN. Function-pointer syntax sabko darrata hai. Lekin hamara rule abhi bhi kaam karta hai — name slot beech mein daба hua hai, aur use dhundhna hi poora khel hai. Dekho Function Pointers.

PICTURE. typedef hatao, phir name slot dhundho. Parentheses (*Operation) * ko naam ke saath group karte hain (forcing "pointer to function", "function returning pointer" nahin). Naam se baahir ki taraf padhne par:

$\underset{\text{returns int}}{\underbrace{\text{int}}}\underset{\text{pointer to...}}{\underbrace{\text{(*}\stackrel{\text{name slot}}{\overbrace{\text{Operation}}}\text{)}}}\underset{\text{...ek function jo (int,int) leta hai}}{\underbrace{\text{(int, int)}}}$

• Operation — name slot ⇒ yahi alias banta hai.
• (* ... ) — pointer, parenthesise isliye kiya taaki call parens se pehle bind ho.
• (int, int) — function ke parameters.
• int (dum left) — function ka return type.

Toh Operation = "ek function ka pointer jo do ints leta hai aur int return karta hai." Usage:

int add(int a, int b){ return a + b; }
Operation op = add;
int r = op(2, 3);   // r = 5

Ek-picture summary

KYA. Ek flow jo har step compress karta hai: typedef dhako, variable declaration ki tarah padho, name slot tumhara alias hai, us naam ka jo bhi type hota woh alias ki meaning hai — aur * hamesha naam ke saath sawaar rehta hai.

Connections

• Typedef — parent topic.
• Structures in C — Step 6, struct keyword hataana.
• Pointers in C — Steps 3–5, jahan * bind karta hai.
• Function Pointers — Step 7, boss decode.
• Linked Lists — real-world typedef struct node Node;.
• Hinglish version →