Another way of implementing zero-length arrays?

Question

I was reading about zero-length arrays, where and how it is used and all. And I understood that they are used when one want a dynamically sized member in one's structure. It is different from using a pointer because

• It lets you allocate the memory for the struct and for variable-length the array at the end of the struct as one continuous memory block.
• If you used a pointer, you'd either have to allocate memory separately (two malloc calls, likely non-continuous) or use some other tricks (to achieve proper alignment etc.).

as taken from this answer.

---

Now, all this is good and ok. Until I read some more older facts about this issue.

Fact 1

• In ISO C90, you would have to give contents a length of 1, which means either you waste space or complicate the argument to malloc.

Fact 2

• GCC allows this feature as an extension.

Now I really don't know what an extension means here. But what I am thinking about is about Fact 1. More explanation ahead.

---

Lets look at some code.

#include<stdio.h>
#include<stdlib.h>

struct line
{
    int len;
    char* content;
};

int main()
{

    int i;
    struct line* p = malloc(sizeof(struct line) + 10);
    p->len = 10;
    p->content = (char*)(&(p->len) + 1);

    printf("%p\n", &(p->len));

    for(i = 0; i < 10; i++)
    {
        printf("%p\n", &(p->content[i]));
    }

}

This piece of code that I came up with effectively implements all the features of the zero-length array. May be there is a line of code extra, but it is definitely better then the bad effects Fact 1 has.

So, my question is, was there any particular reason why the above way (demonstrated in the code above) was not used and they had to add an extension to GCC, or use an array of size 1.

Answer 1

This approach does not work when len > 0.

It saves in the content field 2 things, the address of the array and the first elements of the array.

A re-write of code to demonstrate the effect.

#include<stdio.h>
#include<stdlib.h>

struct line
{
    int len;
    char* content;
};

int main()
{

    int i;
    size_t size = sizeof(struct line) + 10;
    struct line* p = malloc(sizeof(struct line) + 10);
    memset(p, 0, size);
    p->len = 10;
    p->content = (char*)(&(p->len) + 1);

    printf("%p\n", &(p->len));

    for(i = 0; i < 10; i++)
    {
        printf("%p %02hhX\n", (void*) &(p->content[i]), p->content[i]);
    }

}

Output

0x80028260
0x80028264 64  // content address takes up same space as char array
0x80028265 82
0x80028266 02
0x80028267 80
0x80028268 00
0x80028269 00
0x8002826a 00
0x8002826b 00
0x8002826c 00
0x8002826d 00

Answer 2

The reason you'd declare char content[1] instead of your approach is to keep your structure directly serializable and deserializable. Think about what would happen if you wrote your line structure over a network socket or to a file for another application to read. The line->content pointer would be completely invalid for the receiving application.

If you declare the content as an array of size one, you don't have the above problem. However you do have to slightly complicate your malloc call.