Good examples using 'union' with 'enum'? - c

Question

What I try to understand the following:
'Union' acts like like a variable and I can store value in it of different types.
What if in it stored value of type 'float', but I read it as 'short'?
Is there any ways how I can be sure about type of value I am going to retrieve from union ?
How can I deal with kind of cases ?
I saw a note somewhere, He talked about using 'enum' for cases like this, but there was no good enough explanation of why ?
Could you explain why is it useful/safe using 'unions' with 'enums', please ? Or show some examples.
Thanks in advance, Nick.

Answer 1

I believe it is a way of implementing tagged unions or sum types.
E.g. in C99 using an anonymous union
enum kind_en { knothing, kint, kfloat, kstring };
struct value_st {
enum kind_en kind;
union {
int n; // when kint
float f; // when kfloat
char* s; // when kstring
};
};
then e.g.
void print_value (struct value_st* v) {
if (!v) {puts("nil"); return; };
switch (v->kind) {
case knothing: puts("nothing"); return;
case kint: printf("int#%d", v->n); return;
case kfloat: printf("float#%g", v->f); return;
case kstring: printf("string'%s'", v->s); return;
default: abort();
}
}
struct value_st* make_int_value(int i) {
struct value_st* val = malloc(sizeof(struct value_st));
if (!val) { perror("malloc int value"); exit(EXIT_FAILURE); };
val->kind = kint;
val->n = i;
return val;
}
A much older example from the previous century is the XEvent type of Xlib
Notice that some programming languages have an easier way of supporting sum types. In Ocaml you need just
type val_t =
Knothing | Kint of int | Kfloat of float | Kstring of string;;
and most importantly you have pattern matching

Answer 2

Answers to your questions:
Yes, encode the type into a struct that contains the union:
union {
float f;
int i;
} my_union;
enum {
its_a_float,
its_an_int
} flavor;
struct {
flavor x;
my_union u;
} data_blob;
Not sure I grok your question, what sort of cases?
see above
It's useful for when you don't know the exact data you have/need at compile time and need to handle multiple flavors of the same logical data.

Answer 3

Add new filed of type enum and keep there information about current type
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
typedef enum types_tag {
CHAR,
INT,
FLOAT
} types_t;
typedef union value_tag {
char c;
int i;
float f;
} value_t;
typedef struct store_tag {
types_t type;
value_t value;
} store_t;
void printValue(const store_t *o) {
switch (o->type) {
case CHAR:
printf("%c\n", o->value.c);
break;
case INT:
printf("%d\n", o->value.i);
break;
case FLOAT:
printf("%.3f", o->value.f);
break;
default:
exit(EXIT_FAILURE);
}
return;
}
void main() {
store_t a;
a.type = CHAR;
a.value.c = 'A';
printValue(&a);
a.type = FLOAT;
a.value.f = 10.45;
printValue(&a);
_getch();
}
Beside that, you can keep information just in bunch of memory and use void*
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
typedef enum types_tag {
CHAR,
INT,
FLOAT
} types_t;
typedef struct store_tag {
types_t type;
void* value;
} store_t;
void printValue(const store_t *o) {
switch (o->type) {
case CHAR:
printf("%c\n", *(char*)(o->value));
break;
case INT:
printf("%d\n", *(int*)(o->value));
break;
case FLOAT:
printf("%.3f", *(float*)(o->value));
break;
default:
exit(EXIT_FAILURE);
}
return;
}
void main() {
store_t a;
a.type = CHAR;
a.value = malloc(1);
*((char*) a.value) = 'A';
printValue(&a);
free(a.value);
a.type = FLOAT;
a.value = malloc(sizeof(float));
*((float*) a.value) = 34.7;
printValue(&a);
free(a.value);
_getch();
}
and add some functions to hide creating and deleting variables.