Table of Contents
A
function may be called with a varying number of arguments of varying types.
The include file declares a type and defines three macros for stepping
through a list of arguments whose number and types are not known to the
called function. The called function must declare an object of type which
is used by the macros and The macro initializes for subsequent use
by and and must be called first. The parameter is the name of the last
parameter before the variable argument list, i.e. the last parameter of which
the calling function knows the type. Because the address of this parameter
is used in the macro, it should not be declared as a register variable,
or as a function or an array type. The macro returns no value. The macro
expands to an expression that has the type and value of the next argument
in the call. The parameter is the initialized by Each call to modifies
so that the next call returns the next argument. The parameter is a type
name specified so that the type of a pointer to an object that has the
specified type can be obtained simply by adding a * to If there is no
next argument, or if is not compatible with the type of the actual next
argument (as promoted according to the default argument promotions), random
errors will occur. The first use of the macro after that of the macro
returns the argument after Successive invocations return the values of
the remaining arguments. The macro handles a normal return from the function
whose variable argument list was initialized by The macro returns no
value.
The function takes a string of format characters and prints
out the argument associated with each format character based on the type.
void foo(char *fmt, ...) { va_list ap;
int d;
char c, *p, *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 */
c = va_arg(ap, char);
printf("char %c\n", c);
break;
}
va_end(ap);
}
The and macros conform to
These macros are
compatible with the historic macros they replace. A backward compatible
version can be found in the include file
Unlike the macros, the
macros do not permit programmers to code a function with no fixed arguments.
This problem generates work mainly when converting code to code, but
it also creates difficulties for variadic functions that wish to pass all
of their arguments on to a function that takes a argument, such as
Table of Contents