Thread: Functions taking ? # of args

What is the best way to create a function that takes an undeermined amount of arguments?

I remember reading about using an elipsis (...) I think, and I've seen functions, for example, in SDL where it takes more than one using "|" ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) ) . How does that work anyway?

you could try using a macro, but it would only be useful to you in rare circumstances, i.e.

Code:

#define Square(x) (x*x)

You could pass Square(2 + 4); which would expand to 2 + 4 * 2 + 4. Or you could try to overload the function and have default paramters, i.e.

void func(int a, int b, int c, int d = 3)
void func(int a, int b, int c = 2, float d = 3.3)
void func(int a, char b = 'c', int c = 2, float d = 3.3)

Only ideas for you to play at.

Look up va_list and va_arg in the <cstdarg> header. That'll allow you to write functions with many parameters (printf style).

The example you gave is only one argument. The '|' operator (inclusive-or) just operates on those two arguments and passes the result to the function. Conceptually, it would be the same if '+' replaced '|'.

"I remember reading about using an elipsis (...) "

You are misunderstanding what the ellipsis does. You cannot access any of the arguments you send to a function with ellipsis. So, essentially you are calling a function with no parameters--not multiple parameters. Based on that fact and what Zach L. told you, it's most likely you've never seen a function with an indeterminate number of parameters.


You might also check out default parameter values for functions to see if that might work for you. That allows you to send say 4 parameters to a function with 10 parameters. With default values, you can have the rest of the parameters assigned 0 or 1 or whatever works for you.

Thanks for your suggestions guys. What I really was looking for was something like Zach said, since its not really a problem if I know it wont go over a certain amount of arguments. (I was thinking rather than taking up to, say 5 args, taking 5 or more args)

Originally posted by 7stud
"I remember reading about using an elipsis (...) "

You are misunderstanding what the ellipsis does. You cannot access any of the arguments you send to a function with ellipsis. So, essentially you are calling a function with no parameters--not multiple parameters.

Not quite so. You can access the unnamed arguments with va_list, va_arg, and va_end. printf is an example of a function with an undetermined number of arguments.

I do caution you against using this though. One, it is difficult to predict how many arguments have been passed, and two, there is no type checking on these arguments. As you might imagine, this is a rather error-prone technique, mainly left in place to accomodate the existence of printf and its relatives.

Chances are 7stud's idea of default parameters will provide a better solution to the problem you are working on.

Also, a bit more on that SDL example you gave. Lets say you have 8 options for a function which can be in one of two states (on or off). Then, each of those options can be represented by its own bit in a char - one option uses the value of the least significant bit, and so on.

For example, you have options a and b, and this is what they look like:

a (on) 00000001
a (off) 00000000

b (on) 00000010
b (off) 00000000

Then a and b both on could be represented as 00000011. This enables you (in some cases) to be more space efficient with arguments.

Cheers

Code:

void func(int a, int b, int c, int d = 3)

the way you said that his idea would work better made it sound like i could pass more than 4 arguments to that function. is that what you meant? if so, how?