So, I think that, an int, is 32bits, in a x86(32bits) system, this will hold all address of memory. So, if I get all arguments with a int, it will not be a problem, for example, "Hey, I'm a string" the address of this string, fit normally in a 32bits variable, so, i need only to make a cast.

Im right?
Can I do it?
Note: I don't want to make my function like printf (this solution, don't fit in this case ok?)

5 Answers
5

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:

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).

Can you explain more better this? I think that I understood, for example, I can make a enum with the possible types { INT, SHORT, CHAR, ARRAY...ETC }, than, the i will make a struct with two fields, one field have the type of enum right? and the other one have the value ok? its correct? how to hold the value? sorry if i'm wrong and thanks for your answer.
–
drigoSkalWalkerNov 7 '09 at 0:41

You can't do this with variable arguments the way you're describing because no information about the type of the arguments you pass is retained after compilation unless you do it explicitly. Even passing the address of the argument variable won't tell you this, because the bits in memory that represent a string could represent a number or something else.

To make varargs work with variable types, you can store type information in the arguments themselves (e.g., as described by jldupont in his answer), or you can store the information in a non-variable argument (e.g., a format string like printf's).

There is no mechanism defined for determining the [...] types of the unnamed arguments passed to the function. The function is simply required to know or determine this somehow, the means of which vary.

That is your function can't know just from the arguments which arguments are strings. You will need to tell your function what to expect somehow. That is why the printf convention is so common.

We understood that. There is no easy way to accomplish what you've asked for. You must find a way to tell a varags function what kind of data is in the arguments. The printf convention isn't the only choice (see the link or jldupont's answer), but you always have to say.
–
dmckeeNov 7 '09 at 1:18

Ok dmckee, thanks for your answer, i only want to get other way to accomplish this ok? anyway, thanks for your answer guy! ;D
–
drigoSkalWalkerNov 7 '09 at 12:42

Try u?intptr_t, which is defined in stdint.h. This is an integer which is guaranteed to be big enough to hold a pointer.

You might also want to think about what happens when you pass a floating point number; it is converted to and passed as a double. If your program is expecting an int this will destroy its view of the stack. Ouch. And the compiler cannot catch this.

And your function, as defined, has (barring any bit-encoding in paramN, in which case it should be an enum or bitfield, or, at least, unsigned) no way of knowing what the type of parameters it receives are, and as such is unlikely to be able to do anything useful with them. C has no run-time type information on its objects.

Hi man, your answer is great, i'm trying to pass some function points to my function of variable arguments, but between ones, i will pass a string or a int too, i think that i have no problem to use int to accomplish this, or, to use intptr_t too, what you tell me about it? thanks for your answer o/
–
drigoSkalWalkerNov 7 '09 at 0:28

Your program has to know what the type of each argument is, and the only way to to know this in your function is to somehow pass that information through your arguments. If you call printf like printf("%s:%d","string",i) it uses its first argument as a string and second as an int because the format string tells it to do that. If the user passes something else, like printf("%s:%d",0,"x") printf can't know that, and your program is in error. How are you telling your functions how to use its arguments? How does it know which ones are ints, which are strings, which are pointers, &c?
–
Tim SchaefferNov 7 '09 at 21:10