How to manipulate an array of structs with const members - c

Question

I'm trying to understand how 'const' works in C.
What I would like to create is a polygon struct whose members cannot be mutated.
I started by creating the following structs
struct vector2{
float x;
float y;
};
struct polygon2{
const size_t count;
struct vector2* const points;
};
To create a polygon I created the following function:
struct polygon2* polygon2_create(size_t count)
{
struct vector2* points = calloc(count, sizeof *points);
struct polygon2 temp = {.count = count,
.points = points};
struct polygon2* actual = malloc(sizeof *actual);
memcpy(actual, &temp, sizeof(*actual));
return actual;
}
I believe this function doesn't cause undefined behavior.
This way I can do things like
struct polygon2* poly = polygon2_create(30);
poly->points[3] = (struct vector2){7.1, 5.3};
But I can't do
poly->points = NULL;
Nor
poly->count = 3;
Which is great. I'm sure that I won't accidentally change the contents of struct polygon.
But I'd like to make vector2's members const too.
If I change vector2 to:
struct vector2{
const float x;
const float y;
};
I no longer am able to do this:
poly->points[3] = (struct vector2){7.1, 5.3};
I'd like to know why. I expected that making vector2's members const I wouldn't be able to do this
poly->points[3].x = 3
But I'd still be able to do this
poly->points = otherpoint;
Can someone explain what am I missing? And how can I achieve the following:
create a "immutable" vector2 struct
create a polygon struct whose points or count member can't be changed, but the things pointed by points can be 'swaped'.

Answer 1

const qualification of a type means that lvalue expressions of that type are not modifiable. In particular, lvalues of const type or of composite type with at least one const member, recursively, cannot be the left-hand side of an assignment operator, and pointers to such objects cannot be free()d.
Moreover, qualified, including const-qualified, types are different types from their unqualified counterparts and from differently-qualified versions of the underlying unqualifed type. This has implications on compatibility of composite types that have qualified members.
On the other hand, do not mistake const to be a promise that the value is actually constant. It can be the case that the same object can designated by multiple lvalues, some const and others non-const. In that case, the object can be modified via any of the non-const lvalues that designate it, and those modifications will be visible even via the const lvalues that designate it.
With respect to the specifics of your question:
I agree that your function polygon2_create() is valid and has well-defined behavior. In particular, const members of a struct can be initialized in an initializer, and functions such as memcpy() can modify memory in which an object that can be referenced via a const lvalue is stored. Your compiler might warn about the memcpy(), though.
More generally, the initialization and assignment behavior and constraints you describe are correct.
As for poly->points[3] = (struct vector2){7.1, 5.3};, how would it make sense for that to be acceptable if the members of struct vector2 were const? If allowed, the assignment certainly would modify them, and preventing that is exactly the point of const. Or if you prefer a citation to authority, C2011 6.3.2.1/1 specifies that if a structure type has any const members, then lvalue expressions of that type are not modifiable.
It sounds like you are confused about the semantics of whole-struct assignment. If you assign one struct to a different struct, you are not replacing one struct with the other; rather you are copying the value of one struct to the other. This is exactly analogous to assignments to simple types, such as int.
You asked,
how can I achieve the following:
create a "immutable" vector2 struct
You already know how to do this, to the extent that it is possible. If you make all the members const then they cannot be modified via an expression of type struct vector2. As I remarked before, however, this does not confer absolute immutability. C has no such thing.
create a polygon struct whose points or count member can't be changed, but the things pointed by points can be 'swaped'.
I'm not sure I understand how an ability to swap points is consistent with your desired level of unmodifiability. Certainly, if struct vector2 has const members then you cannot assign to lvalue expressions of that type. You could still perform swapping via memcpy(), though, or by casting to a modifiable type. These mechanisms do, however, violate at least the spirit of const-ness. Your compiler will likely warn about them.
You could consider changing points from a struct vector2 * const to a struct vector2 ** const. You can then swap the (non-const) struct vector * objects accessible via *points:
struct vector *temp = poly->points[3];
poly->points[3] = poly->points[2];
poly->points[2] = temp;
Your focus on immutability makes me wonder whether you come from a Java background; either way, that's more Java-esque, since all non-primitives in Java are references, which are more or less pointers.
Overall, however, I think you are overly focused on immutability. const-ness will cause you trouble, especially with memory management. Consider doing without, at least for your struct members themselves. At most, use const qualification on function parameter types to express that the function will not modify the actual argument, and perhaps on global variables where you want at least to be warned about any possibility that they will be modified.