Why is char not a single character?

Question

In Microsoft's documentation for DEV_BROADCAST_DEVICEINTERFACE_A the type of dbcc_name is defined as follows:

char  dbcc_name[1];

But as shown in this StackOverflow question it turns out to be a string with multiple characters.

Isn't a char a 16 bit value single character? How does this work?

_{(I had originally thought that char is 16 bits. Presumably because that's its size in c#. Actually it was probably because I was looking at DEV_BROADCAST_DEVICEINTERFACE_W where it is indeed 2 bytes.)}

Answer 1

Isn't a char a 16 bit value?

On what platform? On most platforms (including all that run Windows, AFAIK), char is 8 bits.

How does this work?

The type documentation explains this:

dbcc_size

The size of this structure, in bytes. This is the size of the members plus the actual length of the dbcc_name string (the null character is accounted for by the declaration of dbcc_name as a one-character array.)

In other words, the definition of _DEV_BROADCAST_DEVICEINTERFACE_A exploits the fact that arrays decay to pointers in C++, and thus dbcc_name, which has array type, can be used as a zero-terminated string in most contexts. The actual string is stored contiguously with the _DEV_BROADCAST_DEVICEINTERFACE_A object, at the address starting at the offset of dbcc_name.

It’s worth noting that the size of the array (1) is unrelated to the length of its contents; it is simply the smallest legal static array size in C++ (legacy code occasionally uses struct members of type char[0]. However, this is a compiler extension and not legal C++).

Answer 2

This is what is known as the "struct hack". It's a trick that allows you to store variably-sized data in a struct instance.

You make the last member an array of size 1, like so:

struct foo { int i; char c[1] };

Assuming a 4-byte int, this type is 5 bytes wide (although it will likely take up 8 bytes to satisfy any alignment requirements), and an instance of struct foo would look like this:

   +---+
i: |   |
   +---+
   |   | 
   +---+
   |   |
   +---+
   |   | 
   +---+
c: |   |
   +---+

However, if you allocate memory for it dynamically with malloc or calloc, you can allocate more memory than just what's needed for the struct type and that extra memory will be considered part of the array (since struct elements are guaranteed to be laid out in the order declared and array types don't enforce sizes).

struct foo *p = malloc( sizeof *p + strlen( "hello" )); 
p->i = 1;
strcpy( p->c, "hello" );

So we allocate enough memory for the struct type (5 bytes) plus enough memory to store "hello", which gives us (assuming little-endian)

   +---+ ----+
i: | 1 |     |
   +---+     |
   | 0 |     |
   +---+     |
   | 0 |     +---- size of struct foo
   +---+     |
   | 0 |     |
   +---+     |
c: |'h'|     |
   +---+ ----+
   |'e'|     |
   +---+     |
   |'l'|     |
   +---+     |
   |'l'|     +---- Extra memory for "hello"
   +---+     |
   |'o'|     |
   +---+     |
   | 0 |     |
   +---+ ----+

Why do we make c an array of size 1 instead of a pointer? If we made c a pointer, like

struct foo { int i; char *c };

then this trick doesn't work, because all c can store is an address, not data.

C allows "flexible array members", where a size isn't needed in the declaration:

struct foo { int i; char c[] };

However, C++ does not (yet) support this, so you have to specify a non-zero size.

Answer 3

it is a very old trick.

typedef struct 
{
    size_t size;
    char str[1];
} mystring_t;

mystring_t *allocate(size_t size)
{
    return malloc(sizeof(mystring_t) + size -1);
}

Then you can easily reallocate it as the flexible part is always at the end of the struct.

In newer C versions

typedef struct 
{
    size_t size;
    char str[];
} mystring_t;

or using gcc

typedef struct 
{
    size_t size;
    char str[0];
} mystring_t;