4

In reference to GCC's Zero Length Array explanation:

This is particularly useful in the case when a struct is a header for a variable-length object. This is exactly my case. Furthermore, I am concerned with the alignment of my structs in the heap.

In this case, I still really do not understand what's useful about zero length arrays. How are they related to this particular situation?

EDIT:

Is it that I can put as much "data" as I want in there?

darksky
  • 20,411
  • 61
  • 165
  • 254

2 Answers2

2

Basically it allows you to have a structure with a variable length array at the end:

struct X {
  int first;
  int rest[0];
};

An array size of 0 is not actually valid (although it is allowed as a gcc extension). Having an unspecified size is the correct way. Since C doesn't really care that you are accessing elements beyond the end of the array, you just start with an undefined array size, and then allocate enough memory to handle however many elements you actually want:

struct X *xp = (struct X *)malloc(sizeof(struct X)+10*sizeof(int));
xp->rest[9] = 0;
Vaughn Cato
  • 63,448
  • 5
  • 82
  • 132
  • Hmm - so it's really related to both issues then. – darksky Mar 22 '12 at 04:25
  • 3
    Ok for the explanation, but just don't use the syntax `[0]` (which is a gcc extension) but either `[]` (which is C99 and supported by gcc as well) or `[1]` which at least gives you defined behavior. – Jens Gustedt Mar 22 '12 at 07:24
  • `[1]` will crash with FORTIFY_SOURCE. Out of bounds access is not actually defined. `[]` works well, `[0]` is not as portable but sould(tm) work on gcc. – domenukk Jan 15 '20 at 15:24
0

The memory returned from malloc() that you will assign to a pointer to the struct with the zero-length array member will be aligned memory ... that's required by the C99 specification. So there is no issue overlaying a struct with a zero-length array over memory allocated from the heap via malloc().

Where you would run into trouble would be attempting to overlay your struct over some raw buffer in memory that came from a packed or non-traditionally aligned data-source, such as a file-header, memory-mapped hardware interface, etc. In those cases, using a zero-length array to handle the variable-length data can be a bad idea since the data may not be aligned according to the default alignment parameters of the platform, and thus offsetting into the array will not yield the correct results.

Jason
  • 31,834
  • 7
  • 59
  • 78
  • I am actually implementing `malloc()`, which is why I am worrying about alignments myself. – darksky Mar 22 '12 at 04:29
  • How are you implementing `malloc` ... through `mmap`? At some point you are going to have to request memory from the OS ... that memory will be aligned. Non-traditionally aligned memory would be something like a packed or "raw-buffer" data-source, memory-mapped hardware interface, etc. When I say "non-traditionally", I'm referring to the fact that even though the buffer might be composed of an `int`, a `char`, etc., you couldn't simply make a `struct` containing those elements, overlay it on the buffer, and not expect padding added by the compiler to interfere with the overlaying operation. – Jason Mar 22 '12 at 04:32