Optional Function Parameters after ...

Is this possible? I thought I had seen this sort of thing somewhere, but I can't find it or replicate it. This is my attempt:

Code:

void example(int notimportant, ..., int terminator = 0)

Thought that would be a really cool way to handle variable arguments... That way, you wouldn't have to supply NULL or 0 at the end.

Look into stdarg.h - va_arg() va_start(), etc.

1 - The elipses has to be the final argument in the function.
2 - There are no default values in C. (The = 0 is invalid.)
3 - You don't have to have NULL at the end. You don't append a null when using printf do you?

Quzah.

printf() uses a format string to get its arguments... I was just trying to get rid of any need for that.

Right, but it still doesn't have the argument list end in a NULL as you describe. Furthermore, you can pass NULL pointers to printf and have it handle them. You wouldn't be able to do this in your example, because that would signify the end of the arguments, when there would actually be more.


Quzah.

Originally Posted by LPP

printf() uses a format string to get its arguments... I was just trying to get rid of any need for that.

Have you read the manual on va_arg?
printf uses format cause the optional argument lst is flexible.

In your case - you know exacly what you get, if you get something

So in your function you should initialize variables representing optional parameters with default values, then process the va_arg array to reinitialize the part of them with the values supplied, then do your stuff

From Linux manpages:

EXAMPLE
The function foo takes a string of format characters and prints out the
argument associated with each format character based on the type.

Code:

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

              void foo(char *fmt, ...) {
                   va_list ap;
                   int d;
                   char c, *s;

                   va_start(ap, fmt);
                   while (*fmt)
                        switch(*fmt++) {
                        case ’s’:           /* string */
                             s = va_arg(ap, char *);
                             printf("string %s\n", s);
                             break;
                        case ’d’:           /* int */
                             d = va_arg(ap, int);
                             printf("int %d\n", d);
                             break;
                         case ’c’:           /* char */
                             /* need a cast here since va_arg only
                                takes fully promoted types */
                             c = (char) va_arg(ap, int);
                             printf("char %c\n", c);
                             break;
                        }
                   va_end(ap);
              }

Also notice the variable arguments are the last paramether of the function so your declaration is invalid. It must end with "...". So

Code:

void foo(int a, ...,int b)

is invalid you must declare

Code:

void foo(int a, int b, ...)

> printf() uses a format string to get its arguments... I was just trying to get rid of any need for that.
And exec functions use a NULL pointer to mark the end of the list.

Or you could do
int adder ( int numvals, ... );

And do
result = adder ( 5, 1, 1, 1, 2, 2 );

Somehow, you need to count the number of args in a variadic function.
- encode the number in a format string, like printf/scanf
- mark the end of the list with some special value, like exec functions do with NULL
- explicitly state the number of parameters, like the adder function above.