Why not use "c struct" like this? [closed] - c

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 months ago.
Improve this question
Please give me the answer. Thanks
struct ZMessage {
uint8_t id[sizeof(struct ZID)];
struct ZBlock block[1]; //what different 'ZBlock block'
};

Answer 1

C and C++ are different languages.
struct ZBlock block[1]; is a C syntax.
In classic C a name of struct is ... not a type. It's a name of block (of variables). C got concept of anonymous struct. Anonymous structs allowed to create separate block of variables or fields with proper alignment, i.e following Test would have field b started from a new word, i.e. size of block will be 4 if size of short is 2.
// this is correct ONLY in C
int main(void)
{
struct Test {
short a : 5;
struct {
short b : 5;
short c : 6;
};
};
// you can have a name of variable matching a name of block.
// regardless of name, declaration without struct is forbidden
struct Test Test;
Test.b = 3;
printf("Test.b equals to %d, size of test %d", Test.b, sizeof(Test));
// Output: Test.b equals to 3, size of test 4
return EXIT_SUCCESS;
}
Therefore in any context where you declare a variable or function parameter you have to precede struct-id by keyword struct to create a type-id.
In C++ struct is a class-type. It's name can be used as type-id, so you don't need a keyword struct. C++ doesn't allow anonymous structs but allows anonymous unions and anonymous namespace.
In fact that you declare ZMessage without a typedef suggest that it is C++ context or a recent C version. C syntax is supported for backward compatibility of header files.
About array of size 1. In that case expression consisting out of name block is a pointer to array of ZBlock. Using size 1 to declare a flexible array according to C standard is no longer correct.
C had a special rule that you can use pointer arithmetics (and operator[] as extent of that) to access implicitly allocated memory after this struct, if array is the last member of struct and got incomplete type.
In most situations, the flexible array member is ignored. In
particular, the size of the structure is as if the flexible array
member were omitted except that it may have more trailing padding than
the omission would imply
Creation of such might look like this:
// might have size 4 or size 8 - greater than sizeof(short)
struct Test {
short size;
short data[]; // Incomplete array type - C11.
// `short data[1]; is NO longer a flexible array.
};
int count = 10;
// note: C doesn't support Test::data construct
// C++ would require a type cast (Test*)
struct Test* pack = malloc(sizeof(struct Test) + count*sizeof(short));
pack->size = count;
pack->data[0] = 4;
pack->data[1] = 8;
...
Here is a problem with padding. We most likely allocate more memory than we need. correct way is to determine offset of address beyond last element of data[]. In C, while sizeof(Test) can be, e.g. 8, offset of data[0] can be still 2.
// such usage of offsetof is undefined in C++
struct Test* pack = malloc(offsetof(struct Test, data[count]));
C++ explicitly doesn't allow to go beyond boundary of object, i.e. beyond boundary of struct. But some compilers support it as extension, usually with no array size declared in that case or with size 1 in case of some compilers. Caveat with those is that it's not consistent if compiler assumes struct to include first member of single array or array can have a zero length.