YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Data ka designChapter 36 of 73

Flexible array members ko samjhein

Explicit allocation size, logical length, copying aur ownership ke saath checked header-plus-payload model banayein.

6 min readCore conceptsC17 baseline
Offline reading
Is chapter mein8 sections
0% through this chapter

Record ke fixed members ke baad variable amount ka data chahiye ho sakta hai. Flexible array member yeh arrangement support karta hai, lekin allocation mein data ke liye room hona chahiye. Stored length aur actual capacity ka agree karna zaroori hai.

1. Flexible member tail describe karta hai, pointer nahi

Flexible array member incomplete array hai jo structure ka last member hota hai, aur kam se kam ek aur named member required hai. Uske elements appropriate member offset ke baad same allocated object ki storage use karte hain. Pointer member alag hai: woh address store karke separate allocation refer kar sakta hai. Empty brackets standard zero-length array declaration nahi hain.

Ek allocation
fixed information
length = 3
flexible payload
data[0], data[1], data[2]
Logical regions hain, exact byte boundaries nahi. Checked allocation padding aur member offset account karti hai; length access bound rehta hai.

2. Intended payload allocate aur initialize karein

Byte-buffer example unsigned char use karta hai, isliye har payload element ek C byte hai. Allocation ke liye <stdlib.h> aur SIZE_MAX ke liye <stdint.h> include karein. Assertions <assert.h> use karti hain. Helper overflowing total reject, allocation failure check, logical length record aur ownership return karne se pehle payload initialize karta hai.

Complete C17 program
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>

struct Buffer {
    size_t length;
    unsigned char data[];
};

static struct Buffer *make_buffer(size_t length)
{
    if (length > SIZE_MAX - sizeof(struct Buffer)) return NULL;
    struct Buffer *buffer = malloc(sizeof *buffer + length);
    if (buffer == NULL) return NULL;
    buffer->length = length;
    for (size_t i = 0; i < length; ++i) buffer->data[i] = 0;
    return buffer;
}

int main(void)
{
    struct Buffer *buffer = make_buffer(3);
    if (buffer == NULL) return EXIT_FAILURE;
    buffer->data[0] = 4;
    buffer->data[2] = 6;
    assert(buffer->length == 3);
    assert(buffer->data[1] == 0);
    assert(buffer->data[2] == 6);
    free(buffer);
    return 0;
}

Extra allocation deliberate hai. Sirf standalone struct Buffer define ya uski length three set karna three payload elements reserve nahi karta. One byte se bade element type ke liye sizeof *p + count * sizeof p->items[0] calculate karne se pehle multiply-and-add check karein; byte example ka addition-only guard har element type ke liye sufficient nahi.

3. sizeof aur payload offset different facts hain

Ordinary sizeof(struct Buffer) intended runtime payload count nahi karta. Structure mein trailing padding ho sakti hai aur flexible member ka offset us size ke equal hona required nahi. offsetof aur size_t ke liye <stddef.h> include karein; guessed layout ke bajay dono query karein.

C17 · illustrative fragment
struct Buffer { size_t length; unsigned char data[]; };
size_t payload_offset = offsetof(struct Buffer, data);
size_t header_size = sizeof(struct Buffer);

Is byte member ke liye successful checked sizeof *buffer + length allocation ke baad kam se kam length payload bytes available hain. Padding logical request se zyada physical room de sakti hai. Recorded length use karein, inferred spare capacity nahi. Logical length zero ho toh element accesses na karein; header-only allocation data[0] ko application payload use karne ki permission nahi.

4. Logical payload explicitly copy karein

Ordinary structure assignment flexible array ke logical contents clone nahi karti. Fixed structure representation ke saath overlap wali bytes ki incidental copying par rely na karein. Checked size ka doosra object allocate karke known payload separately copy karein. Example do distinct live allocations use karta hai, isliye byte-copy regions overlap nahi karti.

Complete C17 program
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

struct Buffer { size_t length; unsigned char data[]; };

int main(void)
{
    size_t length = 3;
    if (length > SIZE_MAX - sizeof(struct Buffer)) return EXIT_FAILURE;
    struct Buffer *source = malloc(sizeof *source + length);
    if (source == NULL) return EXIT_FAILURE;
    struct Buffer *copy = malloc(sizeof *copy + length);
    if (copy == NULL) { free(source); return EXIT_FAILURE; }
    source->length = length;
    source->data[0] = 4;
    source->data[1] = 5;
    source->data[2] = 6;
    copy->length = source->length;
    if (length != 0) memcpy(copy->data, source->data, length);
    copy->data[0] = 9;
    assert(source->data[0] == 4 && copy->data[2] == 6);
    free(copy);
    free(source);
    return 0;
}

Fixed header length value ki tarah copy hoti hai. Byte payload <string.h> ke memcpy se copy hota hai, is pattern mein nonzero length par. Enclosing allocation release karne se tail bhi release hoti hai. data separately free na karein aur release ya successful realloc replacement ke baad interior pointers retain na karein.

5. Flexible member ki structural constraints hain

C17 mein flexible array member wali structure ko doosri structure ka ordinary member ya array element banana restricted hai; related restrictions aisi structure contain karne wali unions par bhi apply hoti hain. Design ko freely nested variable-sized records tak generalize na karein. Standard initialization normal member initializer se dynamically sized flexible payload provide nahi karti; kuch compilers ki extensions baseline se separate hain.

Buffer counted byte sequence hai, automatically C string nahi. Payload ko length n ki terminated string contain karni ho toh terminator ki room bhi reserve/check aur terminator write karein. Length field interface describe karti hai; allocation size change, bytes initialize ya stored count trustworthy prove nahi karti.

Primary references aur aage padhne ke liye

Aage badhne se pehle

  • Flexible array member fixed structure members ke baad trailing elements support karta hai.
  • Checked allocation arithmetic ko intended tail ke liye storage deni hai.
  • Logical length, initialised payload aur actual capacity consistent honi chahiye.
In ideas ko alag rakhein
Base structure size / Tail capacity
Structure ka sizeof arbitrary runtime trailing elements ki count include nahi karta.
Apne words mein samjhaayein

Flexible-array record payload expose kare, usse pehle kaunsi calculations aur initialisations chahiye?

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.

Count field set karne se kya flexible array member ki space allocate hoti hai?
Har choice ki explanation padhein
  1. Haan, array count ke according automatically grow karta hai.

    Count assignment storage acquire nahi karti.

  2. Haan, header ka sizeof har desired payload include karta hai.

    Type ka fixed size arbitrary extra payload capacity nahi deta.

  3. Nahi. Allocation ko separately sufficient checked capacity deni hoti hai.

    ✓ Sahi reasoning. Count, allocation size aur bounds consistent rakhein; allocate karne se pehle size arithmetic check karein.

C17

Agla idea padhne ke liye tayyar?

Mark this chapter as read whenever you feel ready.

CHAPTER 36 / 73

Is chapter mein

Flexible array members ko samjhein

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