Exercises — Typedef

typedef cover karo → unsigned char Byte; ek variable Byte declare karta hai type unsigned char ka. Isliye Byte, ==unsigned char== ka alias hai. Ek chhota sanity check: unsigned char values $0$ se $255$ tak hold karta hai (yaani $2^8-1$), isliye "Byte" ek fitting nickname hai.

Haan, legal hai. Real hai hi double, toh Real pi = 3.14; bilkul double pi = 3.14; ke jaisa hai. typedef ek naam banata hai, koi nayi cheez nahi — pi ek plain double hai.

typedef cover karo → char *String;. * naam String ke saath bind hota hai, char ke saath nahi. Toh String ek variable hoga type char * ka. Isliye String = ==char *== (pointer to char), char nahi.

Point p;
p.x = 3;
p.y = 4;

Kyun kaam karta hai: alias ke bina aapko struct Point p; likhna padta kyunki C mein struct tag Point ek alag namespace mein rehta hai. typedef Point ko ordinary type namespace mein daal deta hai, toh aap struct keyword hata sakte hain. Dekho Structures in C.

Dono a aur b int* hain. * alias IntPtr ke andar baka hua hai. Jab aap IntPtr a, b; likhte hain toh har variable independently poori aliased type paata hai. Toh a hai int* aur b hai int*.

uint hai unsigned int, toh arithmetic modulo $2^{32}$ wrap around karti hai.

• x + 1 = 6.
• Value $y=4294967295=2^{32}-1$ sabse bada representable value hai, toh y + 1 wrap karke $0$ ho jaata hai. Alias ne kuch nahi badla behaviour mein — yeh abhi bhi unsigned int hai.

#define ek dumb text replacement hai preprocessor ke zariye. INTPTR a, b; literally ban jaata hai:

int* a, b;   // a is int*, b is int

Toh a = int*, b = int.

typedef ek real type alias hai jo compiler samajhta hai. IntPtr c, d; har variable ko poora type deta hai:

• c = int*, d = int*.

Summary: a = int*, b = int, c = int*, d = int*. Yeh crucial typedef vs #define split hai Pointers in C se.

typedef cover karo → int (*Operation)(int, int);. Declarator ko identifier se baahir ki taraf padhो:

1. Operation naam hai.
2. (*Operation) — parentheses * ko pehle bind karne ke liye force karte hain: Operation kisi cheez ka pointer hai.
3. (...)(int, int) — woh cheez ek function hai jo (int, int) leta hai.
4. Pehle wala int return type hai.

Isliye Operation = "pointer to a function jo do ints leta hai aur int return karta hai". Dekho Function Pointers.

Zero usage lines badlengi — yahi toh portability ka poora point hai. Sirf ek typedef line badli. Change ke baad Money hai double, toh Money price = 100; stores 100.0 (ek double). price / 3 ab truncated integer 33 ki jagah fractional result dega. Yeh dikhata hai ki ek policy type (jaise "hum money kaise store karte hain") ko ek naam ke peeche alias karna powerful kyun hai: ek baar badlo, sab kuch follow karta hai.

typedef int (*Operation)(int, int);   // from L3.2
typedef Operation OperationTable4[4]; // NEW alias: array of 4 Operations
 
OperationTable4 table;    // 'table' is an array of 4 function pointers
// suppose table[2] = add;  where int add(int,int){...}
int r = table[2](2, 3);   // calls add(2,3)

Naye typedef ko kaise padhen: typedef cover karo → Operation OperationTable4[4]; OperationTable4 ko array of 4 Operations declare karta hai. Toh identifier OperationTable4 alias ban jaata hai, aur iska matlab hai "array of 4 function pointers". Alias kyon kaam aata hai: kisi bhi alias ke bina, yeh type likhi jaati hai int (*table[4])(int, int); — almost unreadable. Do typedefs se, OperationTable4 table; plain English jaisi padhi jaati hai. Teesri stored operation hai table[2]; add(2,3) call karna jahan int add(int a,int b){return a+b;} gives ==5==.

typedef struct { float x, y; } Vec2;
Vec2 v = {1.5f, 2.5f};
float s = v.x + v.y;   // s = 4.0

Anonymous kyun? Hume kabhi struct ko tag se refer nahi karna, sirf alias Vec2 se, isliye tag naam skip kar dete hain. v.x + v.y = 1.5 + 2.5 = ==4.0==. Dekho Structures in C.

typedef struct node {
    int  data;
    struct node *next;   // must use the TAG here, alias not visible yet
} Node;

Tag node abhi bhi kyun chahiye: struct body ke andar alias Node abhi exist nahi karta (woh typedef naam sirf closing brace ke baad usable hota hai), toh self-reference ke liye struct node * use karna padta hai. Raw member sizes: int data = 4 bytes, struct node *next = 8 bytes → 12 bytes of data. Alignment ke saath, compiler 8 ka multiple banane ke liye pad karta hai, giving sizeof(Node) = 16 bytes. Dekho Linked Lists aur Pointers in C.

Legal hai. Ek typedef doosre alias ko alias kar sakta hai. Chain: Whole → Integer → int. Toh Whole n = 7; sirf int n = 7; hai. Aliasing transitive hai; kisi bhi step par koi "new type" nahi banti, sirf names int ki taraf point karte hain.

typedef cover karo → int Arr[3]; Arr ko array of 3 ints declare karta hai. Toh alias Arr ka matlab hai "array of 3 int". Arr a; isliye a ko array of 3 int banata hai. sizeof(a) = 3 × 4 = ==12== bytes. Yeh array typedefs ki surprising power (aur danger) hai: array-ness naam ke andar chhup jaati hai.

Yeh ek degenerate/edge case hai. C mein, koi bhi array parameter — chahe typedef ke peeche chhupa ho — decay ho jaata hai pointer mein. Toh void f(Arr x) actually hai void f(int *x). f ke andar, x ek pointer hai, toh sizeof(x) = ==8== bytes (64-bit par pointer size), 12 nahi. Lesson: alias array type chhupata hai, lekin array-to-pointer decay rule abhi bhi function boundaries par apply hoti hai — naam ne language ka behaviour nahi badla, sirf spelling badli.

Ek rule jo har level survive karta hai ::: typedef ek naam banata hai, kabhi naya type nahi — behaviour (wraparound, decay, size) bilkul underlying type jaisa hi hai. Arr x as a parameter ka size 12 nahi 8 kyun hai ::: array parameters C mein pointers mein decay karte hain, chahe typedef se ho.