Using an array as flexible storage

thus far we’ve seen a personal home page array as a dynamic, hybrid builtintegrated structure for storbuilt-ing any sort of builtintegrated. This gives us lots extra freedom to make use of an array as a flexible garage integrated for our recordsintegrated. we will mix different records kbuiltintegrated and built-inary dimensions of statistics integrated a built-inunmarried array. We do not should even built-ineintegrated the size or sort of array built-ing tointegrated use. we are able to grow, built-ink, and adjust data to and from an array whenever we want to.
now not best does personal home page permitsintegrated us to create dynamic arrays, but it also offers us with masses of 7fd5144c552f19a3546408d3b9cfb251 functionalities for arrays. as an exampleintegrated: array_built-intersect, array_merge, array_diff, array_push, array_pop, prev, subsequent, built-ing-edgeintegrated, quit, and lots of more.

Type Declaration

A shape with at least one member might also moreover include a unmarried array member of unspecified period on the stop of the structure. that is known as a flexible array member:

struct ex1 
{
    size_t foo;
    int flex[];
};

struct ex2_header 
{
    int foo;
    char bar;
};

struct ex2 
{
    struct ex2_header hdr;
    int flex[];
};

/* Merged ex2_header and ex2 structures. */
struct ex3 
{
    int foo;
    char bar;
    int flex[];
};

Effects on Size and Padding

A flexible array member is handled as having no length whilst calculating the size of a structure, though padding among that member and the previous member of the shape may additionally nonetheless exist:

Usage

you could declare and initialize an object with a structure type containing a flexible array member, however you must no longer try and initialize the flexible array member on the grounds that it’s far treated as though it does now not exist. it is forbidden to try to do that, and assemble mistakes will end result.
similarly, you need to now not try and assign a price to any element of a bendy array member when declaring a shape in this way given that there might not be sufficient padding on the cease of the structure to permit for any items required by the flexible array member. The compiler will no longer necessarily save you you from doing this, but, so this will lead to undefined conduct.

/* invalid: cannot initialize flexible array member */
struct ex1 e1 = {1, {2, 3}};
/* invalid: hdr={foo=1, bar=2} OK, but cannot initialize flexible array member */
struct ex2 e2 = {{1, 2}, {3}};
/* valid: initialize foo=1, bar=2 members */
struct ex3 e3 = {1, 2};

e1.flex[0] = 3; /* undefined behavior, in my case */
e3.flex[0] = 2; /* undefined behavior again */
e2.flex[0] = e3.flex[0]; /* undefined behavior */

The ‘struct hack’

flexible array contributors did now not exist previous to C99 and are treated as mistakes. A common workaround is to declare an array of length 1, a method known as the ‘struct hack’:

struct ex1 
{
    size_t foo;
    int flex[1];
};