Flexible array members ko samjhein
Explicit allocation size, logical length, copying aur ownership ke saath checked header-plus-payload model banayein.
Is chapter mein8 sections
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.
- fixed information
- length = 3
- flexible payload
- data[0], data[1], data[2]
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.
#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.
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.
#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
- WG14 N1570 — public C11 committee draft: 6.7.2.1p3 and p18–p25, 7.19, 7.22.3, 7.24.2.1. C17 baseline ke stable core rules; yeh final ISO publication nahi hai.
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.
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.
Har choice ki explanation padhein
- Haan, array count ke according automatically grow karta hai.
Count assignment storage acquire nahi karti.
- Haan, header ka sizeof har desired payload include karta hai.
Type ka fixed size arbitrary extra payload capacity nahi deta.
- 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.