YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Sahi aur reliable CChapter 64 of 73

External data formats: bytes ka agreement

Explicit record format design, boundaries aur version validation karein; serialization aur raw object storage alag samjhein.

6 min readDevelopingC17 baseline
Offline reading
Is chapter mein8 sections

Saved file doosra build, language ya computer padh sakta hai. Readers ko agreed format chahiye. Serialization logical values ko format mein encode karti hai; decoding unhein reconstruct aur validate karti hai. Format time aur systems ke across interface hai.

1. Object storage automatically file format nahi hai

fwrite se structure likhne par object representation copy hoti hai. Ismein padding aur implementation-specific member encodings ho sakti hain. Byte order, integer width, floating formats aur layout alag ho sakte hain. Pointer values runtime context se judi hain; unke bytes save karna target data save ya next run ka usable pointer recreate nahi karta.

Deliberately narrow matching environment contract mein raw dump useful ho sakta hai. Portable external format ko apni field definitions aur validation chahiye. .bin extension definitions nahi deti. Binary mode stream behavior control karta hai; object representations standardise nahi karta.

2. Encoder se pehle format likhein

Teaching format ek count exactly five octets mein store karta hai. Octet exactly eight bits hai. CHAR_BIT == 8 explicitly require karte hain, taaki ek array element ek format octet ho. Value ke two octets most significant part pehle store karte hain; ise big-endian kehte hain. 256 ka high octet one aur low zero hai.

Octet positionsStored values (hexadecimal)Meaning
0–143 52Format ki pehchaan
201Version 1
3–4high lowUnsigned 0–65535 value; most significant octet pehle

Identification aur version octets decoder ko unrelated ya unsupported records reject karne mein help karte hain. Yeh authentication, integrity protection ya malicious input ki guarantee nahi. Real formats ko unknown versions, maximum lengths, truncated records aur later schema changes ki policies chahiye.

3. Pehle validate, phir commit

Complete C17 program
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <limits.h>
#include <string.h>

_Static_assert(CHAR_BIT == 8, "This format requires eight-bit C bytes");

/* The record is exactly five octets: 43 52 01 high low. */
static bool decode_count(const unsigned char *source, size_t size, unsigned *result)
{
    if (source == NULL || result == NULL || size != 5) return false;
    if (source[0] != 0x43 || source[1] != 0x52 || source[2] != 1) return false;
    unsigned value = ((unsigned)source[3] << 8) | (unsigned)source[4];
    *result = value;
    return true;
}

/* destination provides capacity writable bytes. Failure leaves it unchanged. */
static bool encode_count(unsigned value, unsigned char *destination, size_t capacity)
{
    if (destination == NULL || capacity < 5 || value > 65535U) return false;
    unsigned char record[5] = {
        0x43, 0x52, 1, (unsigned char)(value >> 8), (unsigned char)(value & 255U)
    };
    memcpy(destination, record, sizeof record);
    return true;
}

int main(void)
{
    const unsigned values[] = {0U, 255U, 256U, 65535U};
    for (size_t i = 0; i < sizeof values / sizeof values[0]; ++i) {
        unsigned char record[5] = {0};
        unsigned result = 17U;
        assert(encode_count(values[i], record, sizeof record));
        assert(decode_count(record, sizeof record, &result));
        assert(result == values[i]);
    }
    unsigned char encoded[5] = {0};
    const unsigned char expected[5] = {0x43, 0x52, 1, 1, 0};
    assert(encode_count(256U, encoded, sizeof encoded));
    assert(memcmp(encoded, expected, sizeof expected) == 0);
    unsigned char record[6] = {0x43, 0x52, 1, 1, 0, 0};
    unsigned result = 17U;
    for (size_t size = 0; size < 5; ++size) {
        assert(!decode_count(record, size, &result));
        assert(result == 17U);
    }
    assert(!decode_count(record, 6, &result));
    record[2] = 2;
    assert(!decode_count(record, 5, &result) && result == 17U);
    record[2] = 1;
    record[0] = 0;
    assert(!decode_count(record, 5, &result) && result == 17U);
    assert(!decode_count(NULL, 5, &result));
    assert(!decode_count(record, 5, NULL));
    assert(!encode_count(1U, NULL, 5));
    unsigned char saved[6];
    memcpy(saved, record, sizeof saved);
    assert(!encode_count(1U, record, 4));
    assert(memcmp(saved, record, sizeof saved) == 0);
#if UINT_MAX > 65535U
    assert(!encode_count(65536U, record, sizeof record));
    assert(memcmp(saved, record, sizeof saved) == 0);
#endif
    return 0;
}

decode_count output assign karne se pehle pointers, exact record length, identification aur version check karta hai. Invalid record earlier result unchanged chhodta hai. Encoder byte copy se pehle capacity aur range check karta hai. Yeh chosen transactional policies hain; har encoder ki automatic property nahi.

Unsigned cast left shift se pehle hota hai. Isse small unsigned char aise signed int mein promote nahi hota jiska range 16-bit implementation par shifted value ke liye chhota ho. Har standard unsigned int zero se 65535 represent kar sakta hai, jo field ka range hai.

4. Size argument accessible storage verify nahi karta

Pointer aur size checks actual storage ki quantity discover nahi karte. Non-null source ko stated readable region aur destination ko stated writable capacity provide karni chahiye. Caller ko yeh facts establish karne hain. Successful input ne actual mein jo bytes diye, unhein hi decode karein.

Variable-length records mein allocation se pehle lengths aur header add ya count multiply karne se pehle size arithmetic check karein. Complete, incomplete aur invalid input states alag rakhein. Short network ya file read uninitialised trailing storage ko record ka rest samajhne ki permission nahi.

5. Text formats ko bhi agreement chahiye

Text inspect karna easier bana sakta hai, lekin grammar, encoding, numeric range, escaping aur limits phir bhi chahiye. Decimal separator fixed hai ya locale-dependent, decide karein. Embedded delimiters aur newlines ka representation decide karein. Har project ka format invent karne se standard format aur suitable parser better ho sakte hain.

Sochkar dekhein

File "wb" se kholne par kya structure write karna portable serialization ban jata hai?

Explanation padhein

Nahi. Binary mode structure ka layout, padding, member representation ya meaning define nahi karta. External fields explicitly specify aur encode karein.

Primary references aur aage padhne ke links

Aage badhne se pehle

  • External format fields aur encodings ko raw structure layout se independently define karta hai.
  • Width, octet order, version aur length reader-writer agreement ke rules hain.
  • Result commit se pehle complete record validate aur partial input explicitly handle karein.
In ideas ko alag rakhein
Binary stream / Portable serialization
Binary mode padding, member representations, pointer values ya schema standardise nahi karta.
Apne words mein samjhaayein

Encoder-decoder round trip ke alawa exact expected-byte test useful kyun hai?

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 binary file mode, raw structure dump ko portable exchange format bana deta hai?
Har choice ki explanation padhein
  1. Nahi. Layout, padding, byte order aur representations ka explicit format agreement phir bhi chahiye.

    ✓ Sahi reasoning. Fields aur encoding define karke unhe deliberately serialize aur validate karein.

  2. Haan, binary mode har structure ka layout standardize karta hai.

    Binary mode universal structure representation impose nahi karta.

  3. Haan, sirf sizeof poora external protocol describe karta hai.

    Local byte size bytes ke meanings ya encoding specify nahi karta.

C17

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 64 / 73

Is chapter mein

External data formats: bytes ka agreement

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