How to correctly use flexible array member? - c

Question

Here is a type I declared:
(I declared t_sphere, t_cylinder and t_triangle too)
typedef struct s_intersection{
double t1;
double t2;
int id;
union {
t_sphere sph;
t_cylinder cyl;
t_triangle tri;
} u[];
} t_intersection;
To refer to the union variable inside my struct, I have to know in advance what type it is. This is possible thanks to the id int declared in my struct, but it is very heavy to achieve with the method I thought of.
Here is the function I wrote to allocate a t_intersection variable:
t_intersection *intersection(unsigned int geometric_figure_id, void *figure)
{
t_intersection *p;
if (geometric_figure_id == SPHERE_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].sp));
else if (geometric_figure_id == CYLINDER_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].cy));
else if (geometric_figure_id == TRIANGLE_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].tr));
if (p == NULL)
return (NULL);
memset(&p, 0, sizeof(p));
p->id = geometric_figure_id:
if (geometric_figure_id == SPHERE_ID)
p->u[0].sp = *(t_sphere *)figure;
else if (geometric_figure_id == CYLINDER_ID)
p->u[0].cy = *(t_cylinder *)figure;
else if (geometric_figure_id == TRIANGLE_ID)
p->u[0].tr = *(t_triangle *)figure;
return (p);
}
Is there a better way of achieving this?
EDIT: I added the mallocs I forgot + assigning the id...

Answer 1

You need to always allocate space for the entire union, not just one member. Also, you can use calloc to allocate memory that is zero-initialized.
So you can replace this:
if (geometric_figure_id == SPHERE_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].sp));
else if (geometric_figure_id == CYLINDER_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].cy));
else if (geometric_figure_id == TRIANGLE_ID)
p = malloc(sizeof(*p) + sizeof (p->u[0].tr));
if (p == NULL)
return (NULL);
memset(&p, 0, sizeof(p));
With this:
p = calloc(1, sizeof(*p) + sizeof (p->u[0]));
if (p == NULL)
return (NULL);
To simplify even more, since you're only every creating one instance of the union, you don't need a flexible array member. Just declare your struct like this:
typedef struct s_intersection{
double t1;
double t2;
int id;
union {
t_sphere sph;
t_cylinder cyl;
t_triangle tri;
};
} t_intersection;
And create an instance like this:
t_intersection *intersection(unsigned int geometric_figure_id, void *figure)
{
t_intersection *p;
p = calloc(1, sizeof(*p));
if (p == NULL)
return (NULL);
p->id = geometric_figure_id:
if (geometric_figure_id == SPHERE_ID)
p->sp = *(t_sphere *)figure;
else if (geometric_figure_id == CYLINDER_ID)
p->cy = *(t_cylinder *)figure;
else if (geometric_figure_id == TRIANGLE_ID)
p->tr = *(t_triangle *)figure;
return (p);
}

Answer 2

Bug
memset(&p, 0, sizeof(p)); overwrote the pointer just returned form malloc(). #M.M
Likely wanted memset(p, 0, sizeof p[0]);
Memory usage
You can follow #dbush approach and allocate to the size of the FAM union in all cases.
When the .u member's type is not changed over the life of p, code can be more memory efficient.
OP's original approach reduces over-allocating yet could use some improvements.
t_intersection *intersection(unsigned geometric_figure_id, const void *figure) {
assert(geometric_figure_id < ID_N);
static const size_t fig_size[ID_N] = {
[SPHERE_ID] = sizeof(t_sphere),
[CYLINDER_ID] = sizeof(t_cylinder),
[TRIANGLE_ID] = sizeof(t_triangle),
};
t_intersection *p = malloc(sizeof p[0] + fig_size[geometric_figure_id]);
if (p) {
memset(p, 0, sizeof p[0]);
memcpy(p->u, figure, fig_size[geometric_figure_id]);
}
return p;
}
Advanced
There is another efficiency step discussed here that uses offsetof(p, u) instead of sizeof p[0].