Portability aur explicit assumptions
Supported targets state, ranges check, defined octet format encode aur C17/C23 guarantees ko platform conventions se separate karein.
Is chapter mein8 sections
Portable C mein pehle batate hain ki program ko targets se kya chahiye. Integer ranges, byte sizes, representations aur library support alag ho sakte hain. Silent assumptions ko checks aur clear limits se replace karenge.
1. Kya same rehna chahiye, state karein
Portability selected implementations ke across accepted values, results, formats ya interfaces preserve karna ho sakti hai. Yeh different commitments hain. Source two targets par valid hokar bhi different documented size/representation information produce kar sakta hai. Strict portability language-level goal hai, har library/OS service everywhere available hone ka claim nahi.
2. Ranges aur C-byte properties query karein
_Static_assert(CHAR_BIT >= 8, "C bytes have at least eight bits");
_Static_assert(sizeof(char) == 1, "sizeof counts C bytes");
long supported = INT_MAX;
Sizeof C bytes count karta hai aur sizeof(char) one hai; CHAR_BIT byte ke bits batata hai. Standard int required minimum range deta hai, universally 32 bits nahi. 64-bit OS label har type size decide nahi karta. Long, pointers aur size_t ko same representation assume karne ke bajay limits aur appropriate formats, including size_t ke liye %zu, use karein.
Uint32_t jaise exact-width typedefs matching type available hone par conditional hain. Least-width types exact storage size promise kiye bina minimum range express karte hain. Smaller types, including many typedefs, par integer promotions apply rehti hain. Narrowing se pehle aise type mein destination range compare karein jo comparison correctly represent kar sake.
unsigned int small = 73U;
unsigned long widened = small;
unsigned int restored = 0;
bool fits = widened <= UINT_MAX;
if (fits) restored = (unsigned int)widened;
3. External bytes define karein, objects dump nahi
Little-endian aur big-endian common arrangements hain, C ke only permitted layouts nahi. Padding, signed representation, character encodings aur floating-point formats additional boundaries hain. File/network format explicitly define karein. Yahan format two eight-bit octets, most-significant first hai; eight-bit C byte na ho toh compile-time requirement deliberately target reject karti hai.
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
_Static_assert(CHAR_BIT == 8, "This two-octet format requires eight-bit C bytes");
static bool encode_u16(unsigned int value, unsigned char output[2])
{
if (output == NULL || value > 65535U) return false;
output[0] = (unsigned char)(value / 256U);
output[1] = (unsigned char)(value % 256U);
return true;
}
int main(void)
{
unsigned char bytes[2];
bool accepted = encode_u16(0x1234U, bytes);
assert(accepted && bytes[0] == 0x12U && bytes[1] == 0x34U);
unsigned int value = (unsigned int)bytes[0] * 256U + bytes[1];
assert(value == 0x1234U);
return 0;
}
Arithmetic host object representation read karne ke bajay each octet build karti hai. Caller two writable elements supply karta hai; parameter ki [2] spelling automatic bounds check nahi laati. Example small format boundary hai, complete serialization framework nahi. Real formats ko lengths, versioning, malformed-record handling aur extra-data policy bhi chahiye.
4. Revision kuch choices fix karti hai, sab nahi
Shift count nonnegative aur promoted left operand ki width se less hona chahiye. C23 bound remove nahi karta. Plain char signedness separate implementation choice hai. Bit-level formats mein explicit unsigned operations aur proven ranges use karein; promotions aur widths phir bhi account karein.
5. Language, library, ABI aur OS separate karein
Headers, thread libraries, path syntax, file translation, compiler flags aur binary calling conventions independently vary kar sakte hain. Version macro language revision claim batata hai, har optional library capability nahi. Supported configuration matrix build/test, deliberate restrictions document aur familiar CPU ke unaligned access tolerance se correctness infer na karein.
Primary references aur aage ki reading
- WG14 N1570 — public C11 committee draft: 5.2.4.2.1, 6.2.6, 6.3.1.1–6.3.1.3, 6.5.7, 7.20.1. C17 baseline ke stable core rules ke liye; final ISO publication nahi.
- WG14 N3096 — public C23 working draft: 6.2.6.2, 6.3.1.3, 6.5.7. C23 notes C17 example checks se separately source-reviewed hain.
Next numeric chapter error budget develop karta hai. External data formats explicit widths, order aur validation se readers-writers ka agreement samjhata hai.
Aage badhne se pehle
- Portable design mein pehle required target properties batate hain.
- Language guarantees aur implementation-specific choices alag rakhni hain.
- Explicit conversions, width checks aur format definitions assumptions reviewable banate hain.
In ideas ko alag rakhein
- Compiles elsewhere / Behaves portably
- Doosra compiler accept kare toh bhi saare inputs aur target assumptions par intended behavior same hona establish nahi hota.
Do machines ke beech two-octet numeric format share karne se pehle kaun-si assumptions document karenge?
Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.Apni understanding check karein
Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.
Har choice ki explanation padhein
- Nahi. Suitable type available hone par implementation exact-width typedef deti hai.
✓ Sahi reasoning. Implementation ki facilities check kiye bina optional exact-width type assume na karein.
- Haan, int ka exactly 32-bit hona required hai.
C17 universal 32-bit int require nahi karta.
- Haan, koi bhi header include karne se saari integer widths ban jaati hain.
Header unsupported integer representation create nahi kar sakta.
C17
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Connected ideas expanded lessons mein hain; exact corrections source review mein recorded hain.
Aisi C likhna jo different platforms par identically behave kare, kuch dimensions par attention maangti hai jinhe language deliberately open chhod deti hai:
- Type sizes. Kai 64-bit Unix systems ka LP64 model 64-bit
long/pointers aur 32-bitintuse karta hai; 64-bit Windows ka LLP64longko 32 bits par rakhta hai. Yeh platform conventions hain. Exact-width<stdint.h>types optional hain; available hon tab use karein, ya minimum range chahiye toh least-width types aur limits check karein. - Endianness. Multi-byte values little-endian, big-endian ya other byte arrangements use kar sakte hain; ISO C ek universal byte order prescribe nahi karti. Code jo different machines ke across raw binary data read karta hai — especially network ke over — usse local convention assume karne ke bajaye byte order explicitly handle karna chahiye.
- Alignment. C type ki alignment requirements respect karein. Suitable alignment ke bina object pointer ko doosre object-pointer type mein convert karna hi undefined behavior ho sakta hai; permissive hardware se aisa C code portable nahi banta. CPU unaligned load ko kaise handle karta hai, woh separate implementation detail hai.
- Signed-char ambiguity. Jaisa Section 14 mein note kiya gaya, plain
charka signedness implementation-defined hai, jo character data par comparisons ya arithmetic ka result silently change kar sakta hai.
Feature-test macros (jaise __STDC_VERSION__) aur conditional compilation ek single codebase ko compile time par in differences ke saath adapt hone dete hain, har platform ke liye ek alag source tree ki requirement ke bina.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.