Endianness (big vs little): Worked examples — Hinglish deep dive

5.1.11 · D3 · Hardware › Instruction Set Architecture (ISA) › Endianness (big vs little)

Shuru karne se pehle, do symbols ka ek reminder jo hum poore time use karte hain.

Scenario matrix

Endianness choti lagti hai, lekin iske baare mein questions alag-alag cells mein aate hain. Neeche har class of case hai. Baad ke worked examples mein har ek tag karta hai ki woh kaunsa cell cover kar raha hai, aur saath mein poori grid fill ho jaati hai.

Cell	Scenario class	Kya tricky hai
C1	Ordinary 4-byte int, dono endians	Baseline placement
C2	2-byte (16-bit) value	Chhota $N$ — index range change hoti hai
C3	8-byte (64-bit) value	Bada $N$ — bookkeeping stress
C4	Zero value `0x00000000`	Degenerate: dono endians identical lagte hain
C5	Palindromic bytes jaise `0x12341234`? (partial symmetry)	Kaunse bytes actually move karte hain?
C6	Value jisme middle mein `0x00` / leading zeros hon	Fewer bytes padhna; sign-of-location
C7	Negative int (two's complement, high bit set)	Sign bit MSB mein hota hai — woh kahaan jaata hai?
C8	Ek `char[]` string (scalar nahi)	Endianness apply nahi hoti — yeh trap hai
C9	Memory read karna → value (inverse direction)	Bytes se $V$ reconstruct karo
C10	Cross-endian transmission (network byte order)	Real-world word problem
C11	Type-punning twist: ek 4-byte int ko do 2-byte halves ki tarah padhna	Exam-style; sub-word views
C12	Mixed-type struct memory mein laid out	Har field independently endian-swap hota hai; padding

Ab hum sab walk karenge.

Worked examples

Baseline placement

Worked example C1 —

0x0A0B0C0D (32-bit) ko address 200 par store karo, dono endians Forecast: Aage padhne se pehle, likho ki tumhara kya khayal hai ki address 200 par har convention mein kaunsa byte baithega.

Bytes extract karo. Yeh step kyun? Placement se pehle hume har byte ki significance jaanni chahiye. $b_{k} = ⌊ V /25 6^{k} ⌋ mod 256$ use karke: $b_{0} = 0D, b_{1} = 0C, b_{2} = 0B, b_{3} = 0A$
Little-endian, $mem [i] = b_{i}$ . Kyun? LSB-first matlab ones-byte lowest address par jaata hai, isliye indices seedha copy karte hain: $200 : 0D, 201 : 0C, 202 : 0B, 203 : 0A$
Big-endian, $mem [i] = b_{3 - i}$ . Kyun? MSB-first index ko reverse karta hai taaki sabse bada byte sabse chhote address par aaye: $200 : 0A, 201 : 0B, 202 : 0C, 203 : 0D$

Verify: big-endian row left-to-right exactly number 0A 0B 0C 0D ki tarah padhti hai, aur little-endian row uska exact reverse hai. ✓ Figure s01 dekho — wahi chaar coloured tiles, address slots mein opposite directions mein daali gayi hain.

Alag-alag value sizes

Degenerate aur near-degenerate inputs

Sign bit

Classic trap: strings scalars nahi hote

Inverse direction

Real-world word problem

Worked example C10 — Network par ek port number bhejna

Forecast: ek little-endian laptop ko TCP port 443 ek 16-bit field mein bhejna hai. Memory mein port 443 hai mem: bb 01. Wire par kaunse do bytes jaayenge, aur naive send kya transmit karega?

443 hex mein 0x01BB hai, isliye $b_{0} = BB, b_{1} = 01$ . Laptop ki little-endian memory mein: mem[0]=BB, mem[1]=01. Yeh step kyun? Conversion se pehle hume native layout chahiye.
Network byte order big-endian hai. Protocol MSB first require karta hai, yani wire par 01 BB. Kyun? Dono ends big-endian par agree kar lete hain taaki kisi ko bhi sender ki CPU guess na karni pade.
Naive send(&port, 2) raw memory blast karta hai = BB 01. Receiver big-endian mein padhta hai: $BB \cdot 256 + 01 = 47873$ — galat port. Fix hai htons() jo byte-swap karke 01 BB banata hai.

Verify: correct wire bytes 01 BB big-endian mein decode hote hain $01 \cdot 256 + BB = 256 + 187 = 443$ . ✓ Naive BB 01 decode hota hai $0xBB01 = 47873 \neq = 443$ . ✓ htons/htonl ke liye Network Protocols dekho.

Sub-word views (type-punning)

Worked example C11 — Ek 4-byte int ko do 2-byte halves ki tarah padhna

Forecast: little-endian machine par, uint32_t x = 0xAABBCCDD ko ek pointer ke through do uint16_t halves h[0], h[1] ki tarah reinterpret kiya jaata hai. Woh kya hain?

Memory mein bytes daalo (little-endian). Bytes $b_{0} = D D, b_{1} = C C, b_{2} = B B, b_{3} = AA$ → 100:DD, 101:CC, 102:BB, 103:AA. Yeh step kyun? Type-punning physically jo bytes hain woh padhti hai, isliye pehle hume true layout chahiye.
h[0] 100–101 par bytes ko 16-bit little-endian value ki tarah padhta hai: $DD + CC \cdot 256 = 0xCCDD$ . Kyun? Same LSB-first rule half width par.
h[1] 102–103 par bytes padhta hai: $BB + AA \cdot 256 = 0xAABB$ .

Verify: $0xCCDD = 52445$ aur $0xAABB = 43707$ ; aur reassemble karo $h [0] + h [1] \cdot 2^{16} = 52445 + 43707 \cdot 65536 = 2864434397 = 0xAABBCCDD$ = original $x$ . ✓ Big-endian machine par same trick deta hai $h [0] = 0xAABB, h [1] = 0xCCDD$ — swapped — jo exactly isliye hai ki type-punning code endianness-dependent hota hai. Pointers and Type Punning dekho.

Mixed-type struct

Worked example C12 — Alag-alag widths ke fields wala struct

Forecast: struct { uint8_t a; uint16_t b; uint32_t c; } mein a=0x11, b=0x2233, c=0x44556677 ke saath, guess karo ki har field endianness ke under kitne bytes swap karta hai.

Alignment ke saath offsets assign karo. Yeh step kyun? uint16_t ko even offset par rehna chahiye aur uint32_t ko 4 ke multiple par, isliye compiler padding insert karta hai. Layout: offset 0 = a, offset 1 = pad, offsets 2–3 = b, offsets 4–7 = c. Total size 8.
Har field independently swap hota hai, sirf apne bytes ke andar. Kyun? Endianness har multi-byte scalar par alag act karta hai; a byte aur pad byte kabhi nahi move karte.
- Little-endian: 0:11, 1:pad, 2:33, 3:22, 4:77, 5:66, 6:55, 7:44.
- Big-endian: 0:11, 1:pad, 2:22, 3:33, 4:44, 5:55, 6:66, 7:77.
Field a (1 byte) kabhi nahi badalti; b apne 2 bytes reverse karta hai; c apne 4 bytes reverse karta hai. Padding dono mein same rahti hai.

Verify: b ko little-endian bytes 2–3 se reconstruct karo: $33 + 22 \cdot 256 = 0x2233 = 8755$ . c ko little-endian bytes 4–7 se reconstruct karo: $77 + 66 \cdot 256 + 55 \cdot 25 6^{2} + 44 \cdot 25 6^{3} = 0x44556677 = 1146447479$ . ✓ Figure s05 byte grid ko padding shaded aur har field ke arrows alag-alag swap karte hue dikhata hai.

Coverage check

Recall Kya humne matrix ka har cell fill kiya?

C1 baseline ::: C1 example (0x0A0B0C0D) C2 16-bit ::: C2 example (0xBEEF) C3 64-bit ::: C3 example (0x11..88) C4 zero degenerate ::: C4 example (0x00000000) C5 partial symmetry ::: C5 example (0x12341234) C6 leading zeros / narrow read ::: C6 example (0x00000005) C7 negative / sign bit ::: C7 example (-2 = 0xFFFFFFFE) C8 string not scalar ::: C8 example ("Helo") C9 read back → value ::: C9 example (0x1234CDAB) C10 network transmission ::: C10 example (port 443) C11 sub-word type-pun ::: C11 example (0xAABBCCDD halves) C12 mixed-type struct ::: C12 example (a/b/c with padding)

Connections

Endianness — parent topic — woh core rule jise yeh examples exercise karte hain.
Data Representation — $V = \sum b_{k} 25 6^{k}$ decomposition jis par har example tika hai.
Memory Addressing — offsets aur low/high addresses jo poore use kiye hain.
Network Protocols — C10 ka big-endian "network byte order" aur htons.
Pointers and Type Punning — C11 ka sub-word reinterpretation aur C12 ka struct layout.
Bitwise Operations — shift/mask jo byte extraction implement karta hai.
Instruction Set Architecture (ISA) — CPU ek endianness commit karta hai.