Printable View
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.
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.Code:
#define Square(x) (x*x)
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)
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.Quote:
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.
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
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?Code:void func(int a, int b, int c, int d = 3)
No you cannot pass more than 4 arguments to that function. And, for the bit method, you would pass one integer, but once again that would have a maximum number of bits that you have decided beforehand represent something.
What are you trying to do?