Union member and size of char array in c

Question

Years ago I had a good working experience in C. Now it is rusty. Can not find the correct way to create a union with 2 elements

typedef struct {
// multiple elements
}SETTINGS;

 typedef union{
       SETTINGS PROC;
       unsigned char BYTES[sizeof PROC];
 }PROCESS_SETTINGS;

I want to use sizeof here but can not find how anymore? sizeof PROC reports an error.

Answer 1

The C standard says:

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type.

PROC is not an expression (that would require to go through an object of the union type first, e.g., sizeof(u->PROC)), so you have to use the type instead. And with a type, you must use parentheses:

typedef union {
    SETTINGS PROC;
    unsigned char BYTES[sizeof(SETTINGS)];
} PROCESS_SETTINGS;

Answer 2

There's an odd (but useful) idiom in C that is often found. And you may find it useful here.

typedef union {
    short int x;
    float y;
    unsigned char z[1];
} MyUnion;

int main( int argc, char *argv[] ) {
    MyUnion s;
    s.x = 1000;
    printf("%u %u %u\n", sizeof(MyUnion), s.z[0], s.z[1]);
    return 0;
}

Note that you don't even need to specify the actual extent of z[]. Sizing it to one meets the modern standard for syntax. Exceeding the boundary of any array at run-time is undefined behavior, but so will be using an array to index through any declaration as endian nature and padding/alignment issues are target-dependent, anyway.

---

The use of indices outside the given boundary are found in c-compiler code, libraries (malloc, for example, often uses [-1] as an array index), operating systems, and elsewhere. It's quite common, for example, to find in the use of:

typedef struct {
    int typecode;
    int len;
    char s[1];
} packet_t;

for network packets, object file records, etc. The actual allocation is done through malloc, though, to ensure that the proper size exists. It's not wrong and it's often done.

---

Since it is part of a union, it will start at the beginning. But the size of the union will be determined by the largest item and not by it.

C does require that any object have a unique address. So if the union has no other definitions inside of it, then creating an instance of the object will require space. But this is to merely meet the requirement that different instances have different addresses.

If I were simply trying to create a byte array that maps a union of object(s), I'd definitely NOT bother with a sizeof() operator, at all. I'd just write it like I did above. Saves text and saves the risk of having to edit that line if I change the name of something.

Answer 3

TL;DR: Always use parenthesis after sizeof and it will work.

This is because of the peculiar syntax of the sizeof operator, C11 6.5.3:

6.5.3 Unary operators
Syntax
/--/
sizeof unary-expression
sizeof ( type-name )

As we can see it comes in two forms, one form that can be used for compile-time expressions and does not need parenthesis, and another form that can be used for types, which does need parenthesis.

Meaning:

sizeof 1;     // ok, it's an expression
sizeof int;   // syntax error, it's a type
sizeof (int); // ok

Now, as it turns out, any expression can contain a parenthesis, which is an operator with the highest precedence:

sizeof (1);   // ok, here the parenthesis is an operator of its own not part of sizeof
sizeof (int); // ok, here the parenthesis is part of the sizeof operator syntax

So one can always write a parenthesis after sizeof and it will cover both cases.