Is it okay to type-pun allocated structs varying only in const-ness?

Question

In C (let's say C11 if we need to specific), is the following program well-defined? Will it always print a=3 b=4 or could compiler optimizations affect the output?

(The real-world motivation is to provide a read-only public "view" of a struct that is only supposed to be modified by a particular module, i.e. source file.)

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

struct obj_private {
    int a;
    int b;
};

struct obj_public {
    const int a;
    const int b;
};

int main(void) {
    void *mem = calloc(1, sizeof(struct obj_private));
    struct obj_private *priv = mem;
    struct obj_public *pub = mem;

    priv->a = 3;
    priv->b = 4;

    printf("a=%d b=%d\n", pub->a, pub->b);

    return 0;
}

Answer 1

These two types are not compatible. What you should be doing instead is using a pointer to a const object.

struct obj_private *priv = mem;
const struct obj_private *pub = mem;

Answer 2

In the -fstrict-aliasing dialect of gcc, even structures with the same tag name, whose members are identical, are alias-incompatible if they are declared in different scopes. The only way two structures-type lvalues within a compilation unit will be treated as alias-compatible is if both are based upon the same struct declaration. Structures whose types are declared identically but separately are not alias compatible in the gcc dialect.

Consider, for example:

void test_write(void *p)
{
    struct foo { int x; };
    struct foo *pp = p;
    pp->x = 1;
}
struct foo { int x; };
int test_write_and_read(struct foo *p, int i, int j)
{
    p[i].x = 2;
    return p[j].x;
}
struct foo foo_arr[4];
int test(int i)
{
    test_write_and_read(foo_arr, 0, 1);
    test_write(foo_arr+i);
    return test_write_and_read(foo_arr, 1, 0);
}
int (*volatile vtest)(int) = test;
#include <stdio.h>
int main(void)
{
    int result = vtest(0);
    printf("%d %d\n", result, foo_arr[0].x);

}

In the gcc dialect, even though the type struct foo used within test_write has the same tag name and same members as the struct foo type used elsewhere, gcc will not allow for the possibility that a write to pp->x within test_write() might affect the value of foo_arr[j].x within test(), even though the address foo_arr+j is passed to that function.

Given that the gcc won't recognize any form of compatibility between the structures, despite their having the same tag name and identitical contents, one should not regard similarity between the contents of structures as an indication that gcc will accommodate the possibility of their being used interchangeably.

Answer 3

• void *mem = calloc(1, sizeof(struct obj_private)); Here mem points at a chunk of memory with no effective type and no declared type.
• priv->a = 3; Here one of the locations a gets effective type int ¹⁾.
• int since the lvalue expression priv->a used for the access is of type int ²⁾. Same with b.
• pub->a Here the effective type is lvalue accessed as const int. This is well-defined behavior ³⁾. The effective type is int. The lvalue expression pub->a has type const int - it is not a type compatible with the effective type of the object but it is a qualified version of such a type.

Thus well-defined behavior, the C standard is pretty clear. If these rules make sense to begin with or if the intention of the Committee was to allow this kind of type punning, well that's another story.

---

¹⁾ C17 6.5/6

If a value is stored into an object having no declared type through an lvalue having a type that is not a character type, then the type of the lvalue becomes the effective type of the object for that access and for subsequent accesses that do not modify the stored value.

²⁾ C17 6.5/6

For all other accesses to an object having no declared type , the effective type of the object is simply the type of the lvalue used for the access.

³⁾ C17 6.5.7

An object shall have its stored value accessed only by an lvalue expression that has one of the following types:

• a type compatible with the effective type of the object,
• a qualified version of a type compatible with the effective type of the object,