YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Sahi aur reliable CChapter 61 of 73

Portability aur explicit assumptions

Supported targets state, ranges check, defined octet format encode aur C17/C23 guarantees ko platform conventions se separate karein.

5 min readIntermediateC17 baseline
Offline reading
Is chapter mein8 sections
0% through this chapter

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

C17 · illustrative fragment
_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.

C17 · illustrative fragment
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.

Complete C17 program
#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

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.
Apne words mein samjhaayein

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.

Kya har conforming C17 implementation ko uint32_t dena zaroori hai?
Har choice ki explanation padhein
  1. 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.

  2. Haan, int ka exactly 32-bit hona required hai.

    C17 universal 32-bit int require nahi karta.

  3. 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-bit int use karta hai; 64-bit Windows ka LLP64 long ko 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 char ka 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.

CHAPTER 61 / 73

Is chapter mein

Portability aur explicit assumptions

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping