How to simply access data in a union inside of a struct?

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;

When I use that intersection structure in some code, is there a handy way to refer to the member inside my union ?
e.g. Let's say I want to write a function that acts differently according to the type of geometric_figure it contains. Will I have to do it like this ?

if (geometric_figure_id == SPHERE_ID)
    // I know I will have to refer to p->u with p->u.sph...
else if(geometric_figure_id == CYLINDER_ID)
    // I know I will have to refer to p->u with p->u.cyl...
else if (geometric_figure_id == TRIANGLE_ID)
    // I know I will have to refer to p->u with p->u.tri...

What if I had 10 different geometric_figures types inside my union ? This feels very heavy.
Do you have a more elegant solution ?

I think this old answer covers some examples [Why do we need C Unions?](https://stackoverflow.com/questions/252552/why-do-we-need-c-unions) — paisanco, Feb 05 '23 at 13:49
@paisanco Strangely, that Q/A doesn't seem to mention *anonymous* unions. Such could be less "heavy", in this case. OP: Basically, just remove the `u` from the declaration, then you can directly use syntax like `p->tri` instead of `p->u->tri`. — Adrian Mole, Feb 05 '23 at 14:10
What part of "like this" is it that you would prefer to avoid? An anonymous union would slightly simplify the syntax for accessing union members, but I suspect that what you're talking about is actually dispatching on `geometric_figure_id`. — John Bollinger, Feb 05 '23 at 14:14

John Bollinger · Accepted Answer · 2023-02-05T15:11:16.633

Let's say I want to write a function that acts differently according to the type of geometric_figure it contains. Will I have to do it like this ?

It sounds like an awareness of other languages' support for runtime polymorphic function dispatch may be part of the context for your question. If so, then it's important to recognize that what you're dispatching on here is not the type of any object, as you typically would in (say) C++ or Java, but rather the value of an integer.

If you want to follow different control paths for different runtime values of an integer, then there is no alternative to writing a flow-control statement -- generally an if / else if / else or a switch -- that directs control appropriately.^*

Now, if you were dispatching on type then C does offer type-generic expressions. For the most part, these make sense to use only inside a macro:

#define VOLUME(x) _Generic((x), \
    t_sphere: 4 * PI * (x).r * (x).r * (x).r / 3, \
    t_cylinder: PI * (x).r * (x).r * (x).h, \
    t_cube: (x).edge * (x).edge * (x).edge \
)

In contexts other than a macro, you know the type involved already, so a type-generic expression gains you nothing worth having.

Depending on how much macro magic you want to apply, there are ways avoid writing out long if / else if / else statements or long switch statements by hand. Type-generic macros would likely play a role in something like that. But such a course of action is difficult to implement well. You're more likely to end up with a confusing maintenance nightmare of complex macro stacks than with something that would compare favorably to manually-written switch statements.

^*Or maybe a complex expression with nested use of the ternary operator could be taken as fullfilling that need, but using such an expression is not realistic if it needs to be written and maintained by hand.

Support Ukraine · Answer 2 · 2023-02-05T15:06:24.123

Do you have a more elegant solution ?

Saying "more elegant" makes it opinion based. So instead of "more elegant" solution, I'll rather call this an alternative solution.

To avoid the many nested if-statements (or a big switch-statement), you can add a function pointer. So when you make an instance of t_intersection, you also set the function pointer to point to the function needed for the specific sub-type of t_intersection.

Here is an example based on OPs code with a few modifications to make it simpler.

#include <stdio.h>

#define SPHERE_ID 0
#define CYLINDER_ID 1

double sph_calculation(void* p)
{
    puts("sph_calculation");
    int n = *(int*)p;        // Cast back to correct type
    double res = 1.0/n;
    return res;
}

double cyl_calculation(void* p)
{
    puts("cyl_calculation");
    float f = *(float*)p;      // Cast back to correct type
    double res = 1.0/f;
    return res;
}

typedef struct  s_intersection{
  double       t1;
  double       t2;
  int id;
  double (*calculation)(void*);   // Function pointer
  union {
    int sph;
    float cyl;
  } u;
} t_intersection;


int main(void)
{
    t_intersection m[2];

    m[0].id = SPHERE_ID;
    m[0].calculation = sph_calculation;     // Set function to be called
    m[0].u.sph = 2;

    m[1].id = CYLINDER_ID;
    m[1].calculation = cyl_calculation;     // Set function to be called
    m[1].u.cyl = 3.0;
    
    // Do the calculation for all types without a need for nested if-statements
    for (int i = 0; i < 2; ++i)
    {
        double x = m[i].calculation(&m[i].u);
        printf("%f\n", x);
    }
    
    return 0;
}

Output:

sph_calculation
0.500000
cyl_calculation
0.333333

You could use an *array* of function pointers indexed by the ID, obviating the need to set the function. Kinda poor man's virtual dispatch. In the end, as John's answer also shows, one ends up re-implementing OO mechanisms that OO languages have built-in. — Peter - Reinstate Monica, Feb 05 '23 at 15:12
@Peter-ReinstateMonica Agree... a static constant array of function pointers could also be a way. The best solution doesn't exist in general. It always depends on the task to be solved. — Support Ukraine, Feb 05 '23 at 16:38

How to simply access data in a union inside of a struct?

2 Answers2