C - sizeof() on static char arrays inside a struct - impossible?

I need to store two items per array element — two arrays of char, which might contain null bytes — and then still be able to use sizeof() to get their length. Since these values will not change during execution, I think GCC should be able to handle this.

Here's the code:

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

struct name_data {
    char *name;
    char *data;
} name_bins [] = {
    { "John", "\xAA\xAA\x00\xAA" },
    { "Mark", "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05" },
};

char bin_test[] = "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05";

int main () {
    printf("sizeof(bin_test) = %lu\n", sizeof(b开发者_如何转开发in_test));
    printf("sizeof(name_bins[1].data) = %lu\n", sizeof(name_bins[1].data));
    exit(0);
}

The output of this code is:

sizeof(bin_test) = 11
sizeof(name_bins[1].data) = 8

However, bin_test is equivalent to name_bins[1].data in content — although the type definition is different — bin_test is a char[] and names_bins[1].data is a char*.

Is there a way to define the name_bins array with char[]s instead? Is there a way to force GCC to recognize this values as static constants and return the real content size with sizeof() — which it already calculates at compile time?

---

No, this isn't possible. The size of the struct is constant (sizeof any object name_data is always the same). If it were possible, you could have two objects of the same type, with different sizes.

---

You can almost do what you want by storing the size of data as a separate entry:

struct name_data {
    char  *name;
    char  *data;
    size_t data_size;
} name_bins[] = {
    {
        "John",
        "\xAA\xAA\x00\xAA",
        sizeof("\xAA\xAA\x00\xAA")
     }, {
         "Mark",
         "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05",
         sizeof("\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05")
     }
};

And then:

printf("sizeof(bin_test) = %lu\n", sizeof(bin_test));
printf("sizeof(name_bins[1].data) = %lu\n", (unsigned long)name_bins[1].data_size);

Then you'd just have to make sure your name_bins initialization was right. You could toss a macro in the mix to avoid repeating yourself though:

#define BIN(x,y) { (x), (y), sizeof(y) }

struct name_data {
    char  *name;
    char  *data;
    size_t data_size;
} name_bins [] = {
    BIN("John", "\xAA\xAA\x00\xAA"),
    BIN("Mark", "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05")
};

---

If you think for a bit about what you're asking the compiler to do here, you'll probably realize that what you're asking is not realistic.

In order for the compiler to figure out that sizeof(name_bins[1].data) is 11, it would have to make sure that every possible path that leads to the line of code containing the sizeof has the exact same state when it comes to the name_bins[1].data object.

In the simple example you gave, you might expect the compiler to be able to somehow figure that out. But what if your application becomes more complex ? How will the compiler know that name_bins[1].data still contains "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05" ?

EDIT : Following up from the comments, you could create a new type that holds both the data and the size :

typedef struct ConstByteString {
    const unsigned char* data;
    size_t length;
} ConstByteString;

and then use that :

struct name_data {
    const char* name;
    ConstByteString data;
} name_bins [] = {
    { "John", { "\xAA\xAA\x00\xAA", sizeof("\xAA\xAA\x00\xAA") } },
    { "Mark", { "\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05", sizeof("\xFF\x0A\x00\x33\x01\x01\x03\x04\x04\x05") } },
};