Scale elements of a structure using a cast - c

Question

I got this question/assignment on a test yesterday at university. It goes like this:
Give the following structure:
typedef struct _rect {
int width;
int height;
} rect;
How could you scale the width and height members using a cast to int* without explicitly accessing the two members?
So basically, given that struct, how could I do
rect *my_rectangle = malloc(sizeof(rect));
my_rectangle->width = 4;
my_rectangle->height = 6;
// Change this part
my_rectangle->width /= 2;
my_rectangle->height /= 2;
Using a cast to int or int*?

Answer 1

You can scale reliably only the first member:
*((int *) my_rectangle) /= 2;
This does not violate strict aliasing rule, as the Standard explicitely allows to convert pointer to struct object to the pointer of its first member.
C11 §6.7.2.1/15 Structure and union specifiers
Within a structure object, the non-bit-field members and the units in
which bit-fields reside have addresses that increase in the order in
which they are declared. A pointer to a structure object, suitably
converted, points to its initial member (or if that member is a
bit-field, then to the unit in which it resides), and vice versa.
There may be unnamed padding within a structure object, but not at its
beginning.
Assuming that, there is no padding between those members, the second member may be scaled as well, as long as the pointer is of the same (compatible) type as of the member, that is int.

Answer 2

you have starting address of structure, so you can access individual elements
by incrementing address correspondingly. Here since both types are int you can use integer pointer else better to use char pointer.
int *ptr = my_rectangle;
*(ptr) /= 2;
*(ptr+1) /=2;

Answer 3

What they're trying to teach you is how that struct is represented in memory. It has two int members, so it's possible that within memory it could also be viewed as if it were an array of int. So the following could possibly work.
rect *my_rectangle = malloc(sizeof(rect));
my_rectangle->width = 4;
my_rectangle->height = 6;
int *my_array=(int *) my_rectangle;
my_array[0] /= 2;
my_array[1] /= 2;
But it's a really dirty hack and it's entirely possible that a compiler could store your struct in an entirely different way, such that casting it to an int * would not have the desired effect. So not at all recommended if you want to write good clean portable code IMHO.
And if someone were to change the struct, such as by making width & height be float instead of int, the code would probably compile without any issues or warnings and then not work at all how you'd expect.

Answer 4

This task is rather questionable since you can easily end up with invoking poorly defined behavior.
As it happens, we can get away with it since the types of the struct are int, same as the pointer type, and there is an exception in the strict aliasing rule for this.
There's still the issue of padding though, so we would have to ensure that there's no padding present between the integers.
The obscure result is something like this:
// BAD. Don't write code like this!
#include <stddef.h>
#include <stdio.h>
typedef struct
{
int width;
int height;
} rect;
int main (void)
{
rect my_rectangle;
my_rectangle.width = 4;
my_rectangle.height = 6;
int* ptr = (int*)&my_rectangle;
*ptr /= 2;
_Static_assert(offsetof(rect, height) == sizeof(int), "Padding detected.");
ptr++;
*ptr /= 2;
printf("%d %d", my_rectangle.width, my_rectangle.height);
return 0;
}
It is much better practice to use a union instead. We would still have the same padding issue, but wouldn't have to worry about strict aliasing. And the code turns easier to read:
#include <stddef.h>
#include <stdio.h>
typedef union
{
struct
{
int width;
int height;
};
int array[2];
} rect;
int main (void)
{
rect my_rectangle;
my_rectangle.width = 4;
my_rectangle.height = 6;
_Static_assert(offsetof(rect, height) == sizeof(int), "Padding detected.");
my_rectangle.array[0] /= 2;
my_rectangle.array[1] /= 2;
printf("%d %d", my_rectangle.width, my_rectangle.height);
return 0;
}