为什么我们使用零长度数组而不是指针？

Question

It's said that zero length array is for variable length structure, which I can understand. But what puzzle me is why we don't simply use a pointer, we can dereference and allocate a different size structure in the same way.

EDIT - Added example from comments

Assuming:

struct p
{
    char ch;
    int *arr;
};

We can use this:

struct p *p = malloc(sizeof(*p) + (sizeof(int) * n));

p->arr = (struct p*)(p + 1);

To get a contiguous chunk of memory. However, I seemed to forget the space p->arr occupies and it seems to be a disparate thing from the zero size array method.

Answer 1

If you use a pointer, the structure would no longer be of variable length: it will have fixed length, but its data will be stored in a different place.

The idea behind zero-length arrays ^* is to store the data of the array "in line" with the rest of the data in the structure, so that the array's data follows the structure's data in memory. Pointer to a separately allocated region of memory does not let you do that.

---

^* Such arrays are also known as flexible arrays ; in C99 you declare them as element_type flexArray[] instead of element_type flexArray[0] , ie you drop zero.

Answer 2

The pointer isn't really needed, so it costs space for no benefit. Also, it might imply another level of indirection, which also isn't really needed.

Compare these example declarations, for a dynamic integer array:

typedef struct {
  size_t length;
  int    data[0];
} IntArray1;

and:

typedef struct {
  size_t length;
  int    *data;
} IntArray2;

Basically, the pointer expresses "the first element of the array is at this address, which can be anything" which is more generic than is typically needed. The desired model is "the first element of the array is right here, but I don't know how large the array is".

Of course, the second form makes it possible to grow the array without risking that the "base" address (the address of the IntArray2 structure itself) changes, which can be really neat. You can't do that with IntArray1 , since you need to allocate the base structure and the integer data elements together. Trade-offs, trade-offs ...

Answer 3

These are various forms of the so-called "struct hack", discussed in question 2.6 of the comp.lang.c FAQ .

Defining an array of size 0 is actually illegal in C, and has been at least since the 1989 ANSI standard. Some compilers permit it as an extension, but relying on that leads to non-portable code.

A more portable way to implement this is to use an array of length 1, for example:

struct foo {
    size_t len;
    char str[1];
};

You could allocate more than sizeof (struct foo) bytes, using len to keep track of the allocated size, and then access str[N] to get the Nth element of the array. Since C compilers typically don't do array bounds checking, this would generally "work". But, strictly speaking, the behavior is undefined.

The 1999 ISO standard added a feature called "flexible array members", intended to replace this usage:

struct foo {
    size_t len;
    char str[];
};

You can deal with these in the same way as the older struct hack, but the behavior is well defined. But you have to do all the bookkeeping yourself; sizeof (struct foo) still doesn't include the size of the array, for example.

You can, of course, use a pointer instead:

struct bar {
    size_t len;
    char *ptr;
};

And this is a perfectly good approach, but it has different semantics. The main advantage of the "struct hack", or of flexible array members, is that the array is allocated contiguously with the rest of the structure, and you can copy the array along with the structure using memcpy (as long as the target has been properly allocated). With a pointer, the array is allocated separately -- which may or may not be exactly what you want.

Answer 4

This is because with a pointer you need a separate allocation and assignment.

struct WithPointer
{
    int   someOtherField;
    ...
    int*  array;
};

struct WithArray
{
    int someOtherField;
    ...
    int array[1];
};

To get an 'object' of WithPointer you need to do:

struct WithPointer* withPointer = malloc(sizeof(struct WithPointer));
withPointer.array = malloc(ARRAY_SIZE * sizeof(int));

To get an 'object' of WithArray:

struct WithArray* withArray = malloc(sizeof(struct WithArray) + 
                                            (ARRAY_SIZE - 1) * sizeof(int));

That's it.

In some cases it's also very handy, or even necessary, to have the array in consecutive memory; for example in network protocol packets.