Using a struct that contains a union and a type member

Question

I'm trying to debug a program I'm writing that's using the libvirt library in C.

In part of the program I'm being returned the following struct:

struct virTypedParameter {
    char field[VIR_TYPED_PARAM_FIELD_LENGTH];
    int type;
    union {
        int i;
        unsigned int ui;
        long long int l;
        unsigned long long int ul;
        double d;
        char b;
        char *s;
    } value;
}

So I have a key, value, and value type. I want to be able to print these by passing them to a function.

Is there an easier way to do this other than throwing the type into a switch statement and redirecting to the proper printf statement? I've done so and it's causing a ton of warnings to pop up on compile:

void printVirTypedParameter(virTypedParameter* param) {
    printf("Param type: %d\n", param->type);
    switch(param->type) {
        case 1: //int
            printf("%s : %d\n", param->field, param->value);
            break;
        case 2: //int unsigned
            printf("%s : %u\n", param->field, param->value);
            break;
        case 3: //long long int
            printf("%s : %ld\n", param->field, param->value);
            break;
        case 4: //long long unsinged
            printf("%s : %llu\n", param->field, param->value);
            break;
        case 5: //double
            printf("%s : %f", param->field, param->value);
            break;
        case 6: //boolean (character)
            printf("%s : %c", param->field, param->value);
            break;
        case 7: //string
            printf("%s : %s", param->field, param->value);
            break;
        case 8: //param last
            printf("END_PARAMS");
}

Answer 1

The switch is the way to do it. But you should be using the member of the union that is appropriate for the type that you read, i.e. you should use param->value.i if you know that the type is int. This should avoid any warnings.

So for instance:

switch(param->type) {
        case 1: //int
            printf("%s : %d\n", param->field, param->value.i);
            break;
        // ...
}

Answer 2

The comments to the question cover the obvious problems with the OPs posted code. The following is an example of the code with all the obvious problems corrected.

#include <stdio.h>    // printf()

#define VIR_TYPED_PARAM_FIELD_LENGTH 30

enum VALID_TYPES
{
    INTEGER = 1,
    UNSIGNED_INTEGER,
    LONG_LONG_INTEGER,
    UNSIGNED_LONG_LONG_INTEGER,
    DOUBLE,
    CHAR,
    CHAR_POINTER,
    ALL_DONE
};

struct virTypedParameter
{
    char field[VIR_TYPED_PARAM_FIELD_LENGTH];
    //int type;
    enum VALID_TYPES type;
    union
    {
        int i;
        unsigned int ui;
        long long int l;
        unsigned long long int ul;
        double d;
        char b;
        char *s;
    } value;
};


// prototypes
void printVirTypedParameter( struct virTypedParameter* param);


void printVirTypedParameter( struct virTypedParameter* param)
{
    printf("Param type: %d\n", param->type);

    switch(param->type)
    {
        case INTEGER: //int
            printf("%s : %d\n", param->field, param->value.i);
            break;

        case UNSIGNED_INTEGER: //int unsigned
            printf("%s : %u\n", param->field, param->value.ui);
            break;

        case LONG_LONG_INTEGER: //long long int
            printf("%s : %lld\n", param->field, param->value.l);
            break;

        case UNSIGNED_LONG_LONG_INTEGER: //long long unsinged
            printf("%s : %llu\n", param->field, param->value.ul);
            break;

        case DOUBLE: //double
            printf("%s : %f\n", param->field, param->value.d);
            break;

        case CHAR: //boolean (character)
            printf("%s : %c\n", param->field, param->value.b);
            break;

        case CHAR_POINTER: //string
            printf("%s : %s\n", param->field, param->value.s);
            break;

        case ALL_DONE: //param last
            printf("END_PARAMS\n");
            break;

        default:
            printf( "found unexpected value in 'type' field: %d\n", param->type );
            break;
    }
}