Using a heterogenous array in C

Question

I'm looking to use an array with multiple types -- strings and numbers (int). Here is what I have so far:

int main(int argc, char *argv[]) {

    int number = 2;
    void * array[] = {"helo", &number, "watkins"};
    int array_len = sizeof(array)/sizeof(array[0])

    for (int i=0; i<array_len; i++) {
        void *value = array[i];

        // how to do this in C?
        if (type(value) == char)
            printf("The string is: %s", value);
        else
            printf("The number is: %d", value);

    }

}

How would I test the type or do something equivalent in C?

Answer 1

I like Nate's answer, so don't change your choice, but there is a subtle variation on it using an anonymous union that will allow you to refer to the members of the union directly without the need to use a union tag to reference the member.

This was introduced with the C11 Standard in 6.7.2.1 Structure and union specifiers(p13). It simply provides a bit of syntactical short-hand. For example using an anonymous union within the struct, e.g.

typedef struct {    /* struct containing tag and union between int/char[] */
    int tag;
    union {                 /* anonymous union allow you to refer  */ 
        char str[MAXC];     /* to members as members of the struct */
        int number;
    };
} mytype;
...
    mytype array[] = {{ISSTR, {"helo"}}, {ISINT, {{2}}}, {ISSTR, {"watkins"}}};

Your access to the union members would be:

            printf ("The string is: %s\n", array[i].str);

or

            printf ("The number is: %d\n", array[i].number);

(with no union tag between the array[i] and the str or number)

Putting it altogether, your example would be:

#include <stdio.h>

#define MAXC 16     /* if you need a constant, #define one (or more) */

enum { ISSTR, ISINT };  /* enum can provide global constants as well */

typedef struct {    /* struct containing tag and union between int/char[] */
    int tag;
    union {                 /* anonymous union allow you to refer  */ 
        char str[MAXC];     /* to members as members of the struct */
        int number;
    };
} mytype;

int main (void) {

    mytype array[] = {{ISSTR, {"helo"}}, {ISINT, {{2}}}, {ISSTR, {"watkins"}}};
    int array_len = sizeof array/sizeof *array;

    for (int i=0; i<array_len; i++) {
        // how to do this in C?
        if (array[i].tag == ISSTR)      /* if tag ISSTR element is string */
            printf ("The string is: %s\n", array[i].str);
        else if (array[i].tag == ISINT) /* if ISINT, element holds an int */
            printf ("The number is: %d\n", array[i].number);
        else
            fputs ("As Nate put it, things are horribly wrong...\n", stderr);
    }
}

Example Use/Output

$ ./bin/structunion
The string is: helo
The number is: 2
The string is: watkins

Keep in mind this was introduced with C11, in C99 you will not find an anonymous struct or anonymous union (though some compilers did provide by as an extension)

Answer 2

This feature doesn't exist in C at the level of the language. If you want something like this, you have to create it yourself. So your array elements need to be of a type that can contain either type of object, such as a struct or union. Furthermore, your code has to keep track of which type is which - the language will not do it for you.

So one approach would be something like the following:

#include <stdio.h>
#include <stdlib.h>

enum my_type { IS_STRING, IS_INTEGER };

struct my_multitype {
    enum my_type t;
    union {
        char *s;
        int n;
    } u;
};

int main(int argc, char *argv[]) {

    struct my_multitype array[] =
        {
         { IS_STRING, { .s = "helo" } },
         { IS_INTEGER, { .n = 2 } },
         { IS_STRING, { .s = "watkins" } }
        };

    int array_len = sizeof(array)/sizeof(array[0]);

    for (int i=0; i<array_len; i++) {
        switch (array[i].t) {
        case IS_STRING:
            printf("The string is: %s\n", array[i].u.s);
            break;
        case IS_INTEGER:
            printf("The number is: %d\n", array[i].u.n);
            break;
        default:
            printf("Something is horribly wrong\n");
            abort();
            break;
        }
    }
}

Note that we are using designated initializers to initialize the correct member of the union in each case.

You could also use void * as you tried, but then you have to keep the type information in a separate array or something, and it's awkward. It's also awkward to initialize an array of such things, again as you saw with the integer, where you had to introduce an auxiliary variable.