Question bank — Bit fields in structs

struct { unsigned f : 1; } s;
unsigned *p = &s.f;
``` ::: `&s.f` illegal hai — bit field ka koi address nahi hota. **Fix:** `unsigned t = s.f; unsigned *p = &t;` — pehle ek real variable mein copy karo.
 
```c
struct T { double d : 10; };
``` ::: `double` integer type nahi hai, isliye yeh bit field nahi ho sakta. **Fix:** koi integer base type use karo jaise `unsigned int d : 10;`.
 
```c
struct T { unsigned x : 3; };
struct T s; s.x = 8;
printf("%u", s.x);  // expects 8
``` ::: 3-bit field maximum 7 tak jaata hai. `8 = 1000₂` low 3 bits `000₂ = 0` mein truncate ho jaata hai, toh yeh **0** print karta hai, 8 nahi. Koi warning nahi deta.
 
```c
int flag : 1;   // want a 0/1 flag
``` ::: Do problems hain: plain `int` bit-field signedness implementation-defined hai, aur ek signed 1-bit field reliably 1 hold nahi kar sakta. **Fix:** `unsigned int flag : 1;`. Saath hi, bit fields kisi struct ke andar hone chahiye, akele nahi.
 
```c
struct { unsigned a : 5, b : 5, c : 25; } s;
// programmer assumes sizeof == 4
``` ::: `a`+`b` 10 bits use karte hain; `c` ko 25 aur chahiye lekin pehle unit mein sirf 22 bache hain, toh `c` ek **naya** storage unit shuru karta hai → `sizeof` typically **8** hota hai, 4 nahi.
 
```c
struct { unsigned a : 40; };
``` ::: Kisi field ki width uske storage type ki width se zyada nahi ho sakti (typically `unsigned int` ke liye 32 bits). 40 bits maangna constraint violation hai → compile error.
 
```c
struct P { unsigned x : 3; } arr[10];
printf("%p", (void*)&arr[2].x);
``` ::: Wahi trap array mein sajaya hua: `&arr[2].x` abhi bhi bit field ka address le raha hai → compile error. Pehle ise copy karo.
 
---
 
## Why questions
 
Bit fields integer type kyun use karna zaroori hai, `char[]` ya `float` kyun nahi? ::: Bit-field semantics sirf integer bit patterns ke liye defined hain — puri sankhya ke value bits ki *bits mein width*. Floats mein exponent/mantissa structure hota hai aur arrays ke addresses hote hain, dono hi "N packed bits" model mein fit nahi hote.
 
Bit field ka address kyun nahi le sakte? ::: C addresses byte-granular hote hain, lekin ek bit field ek byte ke beech se shuru ho sakta hai. Koi aisi byte address nahi hai jo "sirf woh 3 bits" ko name kare, isliye `&` forbidden hai.
 
Bit field mein overflow silently wrap kyun karta hai instead of error dene ke? ::: Assignment value ko $2^N$ modulo store karti hai (field ke paas sirf N bits *hain*, toh zyada bits ko jaane ki jagah nahi hai). C ise normal unsigned wraparound treat karta hai, error nahi — wahi philosophy jo `unsigned int` overflow ki hai.
 
Bit field ke liye plain `int` ki jagah explicitly `unsigned` kyun declare karein? ::: Plain `int` bit fields ke liye standard signedness ==implementation-defined== chhod deta hai. `unsigned`/`signed` explicitly likhne se woh range guarantee hoti hai jo tumhein chahiye (0..$2^N-1$ vs $-2^{N-1}..2^{N-1}-1$).
 
Ek struct jo sirf 3 bits total use karta hai uska `sizeof` abhi bhi 4 kyun hoga? ::: Compiler poore storage units (`int` box) allocate karta hai, aur structs apne alignment tak padded hote hain. Teen bits ek full unit tak round up ho jaate hain; tumhare paas koi 3-bit-sized object nahi ho sakta.
 
Bit fields [[Embedded systems / hardware registers]] ke liye specially useful kyun hain? ::: Ek hardware register ek fixed byte/word hota hai jahan individual bits specific cheezein mean karte hain (bit 0 = ready, bits 1–3 = speed). Bit fields ka struct woh layout seedha mirror karta hai, toh `reg.speed = 3;` manual `<< & |` masking se clearer aur safer hota hai.
 
`unsigned : 0;` exist kyun karta hai? ::: Yeh tumhein alignment par explicit control deta hai: yeh current storage unit flush karta hai taaki agla field fresh shuru ho, kisi hardware boundary ya documented file/packet format se match karta hua.
 
---
 
## Edge cases
 
Ek **0-width named** field jaise `unsigned z : 0;` ka range kya hai? ::: Yeh illegal hai — ek *named* zero-width field constraint violation hai. Sirf ek **unnamed** `unsigned : 0;` allowed hai, aur woh kuch store nahi karta (yeh sirf ek alignment marker hai).
 
Ek `_Bool : 1;` field kya store kar sakta hai? ::: Exactly 0 ya 1 (C99 `_Bool`). Koi bhi nonzero assignment 1 mein normalize ho jaati hai, unlike `unsigned : 1` jahan tumhein truly low bit milti hai — genuine true/false flags ke liye yeh ek cleaner choice hai.
 
Kya zaroorat se zyada wide field kabhi *hurt* karta hai? ::: Correctness mein nahi, lekin yeh packing space waste karta hai: 0/1 value ke liye `unsigned flag : 8;` 7 unusable bits burn karta hai aur baad ke fields ko naye unit mein push kar sakta hai, `sizeof` badha deta hai.
 
Exactly top value par kya hota hai, jaise ek 3-bit field 7 set ho? ::: Bilkul theek hai — `7 = 111₂` sab 3 bits ko bina overflow ke fill karta hai. Takleef sirf 8 (`1000₂`) par shuru hoti hai, pehli value jo 4th bit maangti hai.
 
Kya ek bit field do storage units straddle kar sakta hai (jaise ek int ke last 2 bits + agley ke first 3)? ::: Straddling allowed hai ya nahi yeh ==implementation-defined== hai. Kuch compilers boundary par pack karte hain; doosre padding insert karte hain aur field fresh shuru karte hain. Kisi specific behaviour par kabhi rely mat karo.
 
Kya storage unit (`int`) mein bits ki sankhya 32 guaranteed hai? ::: Nahi. Yeh jo bhi platform ka `int` ho (standard ke mutabik kam se kam 16 bits). Portable code [[Data types and sizeof]] se check karta hai aur 32 assume karne se bachta hai.
 
Agar tum ek `unsigned` bit field ko negative number assign karo toh kya hoga? ::: Yeh $2^N$ modulo wrap karta hai bilkul `unsigned` arithmetic ki tarah: jaise `-1` ek 3-bit field mein `111₂ = 7` store karta hai. Koi error nahi; two's-complement low bits rakhe jaate hain.
 
---
 
> [!recall]- Har trap ki ek-line summary
> Fields exactly N bits hote hain (extras gir jaate hain), inका koi address nahi hota, aur lagbhag har layout detail implementation-defined hai — toh `unsigned` declare karo, khud range-check karo, aur physical bit order kabhi assume mat karo.
 
## Connections
- [[Bit fields in structs (index 5.1.23)|Parent: Bit fields in structs]]
- [[Structs in C]] — bit fields special members hain.
- [[Bitwise operators]] — manual mask/shift alternative aur truncation mechanism.
- [[Data types and sizeof]] — storage-unit size aur `sizeof` surprises.
- [[Memory alignment and padding]] — `: 0` alignment trick.
- [[Embedded systems / hardware registers]] — register-mirroring use case.
- [[Unsigned vs signed integers]] — lost sign bit aur wraparound.