Is this a Flexible Array Struct Members in C as well?

Question

Possible Duplicate:
Flexible array members in C - bad?

I read the following code:

struct hello {
    int number;
    int data[1];
};

I know the Flexible array members allow we can declare the last element to be an array of unspecified size like this:

struct hello {
    int number;
    int data[];
};

In this struct, the last element does not specify the size, so what is the difference between these two? and what does the first declaration mean?

You will probably get you answer here : http://stackoverflow.com/questions/246977/flexible-array-members-in-c-bad — Joze, Nov 29 '12 at 09:43
int data[1] means that the int array named data has a size of 1 int. But when you will have to access to it, you will have to access to the first (and only one) element of the array then you will do something like this : myHelloStruct.data[0]=200 (It's an example here). — Joze, Nov 29 '12 at 09:59

hyde · Answer 1 · 2012-11-29T10:31:06.007

1

This kind of array:

struct hello {
    int number;
    int data[];
};

only makes sense as last element of struct, and only when you allocate struct from heap, and typically so that header fields contain the real size of the array:

struct hello *helloptr = malloc(sizeof (struct hello) + count*(sizeof int));
helloptr->number = count;

The use is to allocate header and data buffer conveniently with one struct.

Addition: The difference to your version, which allocates array of size 1 is, sizeof struct hello will be more, since array is allocated with one element instead undefined=zero. This either wastes one item worth of memory, or makes size calculations more complex, and is a bit "ugly" conceptually (your code has size 1 array, when you actually mean "undefined", possibly even 0).

In OOP C++ it's better to just wrap dynamically allocated buffer inside a class, this is kind of a "hack" really.

edited Nov 29 '12 at 10:31

answered Nov 29 '12 at 09:45

hyde

60,639
21
115
176

did not completely understand, but are there any different between these two different forms? – Nov 29 '12 at 09:46
@ratzip The difference is, your first struct (with array size 1) has `sizeof` 8, while the second one (with flexible array) has `sizeof` 4, the array is assumed to be zero sized. – hyde Nov 29 '12 at 10:00
By my understanding, if a struct has a member `unsigned char foo[1]`, a compiler would be legitimately allowed to replace `ptr->foo[intexpr]` with `ptr->foo[0]` since any value of `intexpr` which would go beyond *either* the physical space allocated for the struct or the specified dimension of `foo` would yield undefined behavior. The single-item-array version of the struct hack is common enough I wouldn't expect compilers to apply such an optimization to the last item of a struct which is accessed via ptr, but I know of nothing that would forbid them from doing so. – supercat Dec 03 '12 at 21:36

Alok Save · Answer 2 · 2012-11-29T10:12:01.387

What is the difference between data[1] and data[0]?

Difference is none, both can be used for implementing flexible sized structure.

Raymond Chen answers it aptly:

Okay, you may say, then why not use a zero-length array instead of a 1-length array?

Because time travel has yet to be perfected.

Zero-length arrays did not become legal Standard C until 1999. Since Windows was around long before then, it could not take advantage of that functionality in the C language.

Note that technically, both the second code example is not valid C++ code.^{[Ref 1]} But lot of existing code uses this functionality and this code will almost work always.

^{[Ref 1]}Reference:

C++11 Standard: 8.3.4 Arrays

In a declaration T D where D has the form
D1 [ constant-expressionopt] attribute-specifier-seqopt
....... If the constant-expression (5.19) is present, it shall be an integral constant expression and its value shall be greater than zero.

So why wouldn't the first be not valid C++ ? He has a `1` in there. — Jens Gustedt, Nov 29 '12 at 10:11
@JensGustedt: You caught me in an edit. Sorry that was a typo. — Alok Save, Nov 29 '12 at 10:13

score 0 · Answer 3 · answered Nov 29 '12 at 10:01

It is not a flexible array member but is used in some code that needs to work with old compilers or with c++ compilers.

Using it as a flexible array member might provoke undefined behavior. In real code this should work as expected as this trick is used in too much code for the compiler to make any unexpected things.

score 0 · Answer 4 · answered Nov 29 '12 at 10:14

Both are not completely equivalent in C, even if you only access the first element. A flexible array can have different alignment than the fixed size array would have. So even sizeof could give you different results for both and you should never mix these two variants inside the same code.

Is this a Flexible Array Struct Members in C as well?

4 Answers4

Linked