Variable arguments in C, how to get values with a generic type?

You can't do it the way you describe it.

The C calling convention is for the caller to put arguments on the stack but it does not put any information on types, so the callee must have a way to find it (at least size of variables).

• No problem for functions with prototypes every type is known.

• With functions with variable number or parameters (variadic) it's more tricky, you have to call va_arg for each argument to read each variable and you must provide the type for va_arg. If you provide a type that is not the real one the compiler won't complain (it can't it's runtime information) but anything can happen (usually something bad).

Hence you have to pass the type.

In some cases you can predict type (eg: a counter followed by some ints, and so on), but usually you pass it encoded in parameters. You can pass it encoded in a format string like printf does, the union trick described by jldupont is also common enough.

But anyway you have to pass it.

You really can't rely on underlying data binary representation, not even data size. Even if the program seems to work when you write it, it has no compatibility and can break with any change of the system, of the compiler, or even when changing compiling options.

Let's go with an example where you pass the type followed by the argument (thus neither the union trick nor the format string like printf). What it does is converting all it's passed value to double and add them, no really useful isn't it:

#include <stdio.h>
#include <stdarg.h>

enum mytypes {LONG, INT, FLOAT, DOUBLE };

double myfunc(int count, ...){
    long tmp_l;
    int tmp_i;
    double tmp_d;
    double res = 0;
    int i;

    va_list ap;
    va_start(ap, count);
    for(i=0 ; i < count; i++){
        int type = va_arg(ap, enum mytypes);
        switch (type){
            case LONG:
            tmp_l = va_arg(ap, long);
            res += tmp_l;
            break;
            case INT:
            tmp_i = va_arg(ap, int);
            res += tmp_i;
            break;
            case FLOAT:
            /* float is automatically promoted to double when passed to va_arg */
            case DOUBLE:
            tmp_d = va_arg(ap, double);
            res += tmp_d;
            break;
            default: /* unknown type */
            break;
        }
    }
    va_end(ap);
    return res;
}

int main(){
    double res;
    res = myfunc(5,
        LONG, (long)1,
        INT, (int)10,
        DOUBLE, (double)2.5,
        DOUBLE, (double)0.1,
        FLOAT, (float)0.3);
    printf("res = %f\n", res);
}

This exemple use the new stdarg variadic header defined in C99. To use it you need to have at least one fixed parameter to your function (in this exemple it's count). The good thing if that thus you can have several variadic lists in your function (ie something like myfunc(int count1, ..., int count2, ...)). The bad thing is that you can't have a purely variadic function (ie something like myfunc(...) like with the old format. You can still use the old format using varargs compatibility headers. But it is more complicated and rarely necessary, because you need types but also some way to know the list is finished and something like count is handy (but not the only way to do it, a 'terminator' could be used for instance).

Use a void * (or a typed structure) for each parameter & use a structure with a "type" argument (an integer). A pointer / union to contain the actual value.

In other words, each parameter is passed with a pointer to a typed structure. Each instance of this typed structure contains a value. The type of this "value" is contained in this typed structure.

Better Example:

typedef struct  {
  int type;
  union {
    int int_value;
    double double_value;
    ...
  };
} Param;

void function(Param *p1, Param *p2, ...)

The latest example of such trick I ran into was DBus.