Thread: Variable length function parameters

Hi all.

Take a look at the sample code below and note the line:

ival = va_arg(ap, int)

Does that mean that ap initially points to the first int in the parameters list?
Then more importantly, next time va_arg is called, ap will point to the NEXT INT in the parameters list?

Code:

#include <stdarg.h>

/* minprintf: minimal printf with variable argument list */

void minprintf(char *fmt, ...)
{
	va_list ap; 			/* points to each unnamed arg in turn */
	char *p, *sval;
	int ival;
	double dval;
	va_start(ap, fmt); 		/* make ap point to 1st unnamed arg */
	for (p = fmt; *p; p++)
	{
		if (*p != '%')
		{
			putchar(*p);
			continue;
		}
		switch (*++p)
		{
			case 'd':
			ival = va_arg(ap, int);
			printf("%d", ival);
			break;
			case 'f':
			dval = va_arg(ap, double);
			printf("%f", dval);
			break;
			case 's':
			for (sval = va_arg(ap, char *); *sval; sval++)
			putchar(*sval);
			break;
			default:
			putchar(*p);
			break;
		}
	}
va_end(ap); /* clean up when done */
}

Disclaimer to CommonTater. I am still learning to use the indent feature so dont blast me yet on code readability!

From the man page:

The va_arg() macro expands to an expression that has the type and value
of the next argument in the call. The parameter ap is the va_list ap
initialized by va_start(). Each call to va_arg() modifies ap so that the
next call returns the next argument. The parameter type is a type name
specified so that the type of a pointer to an object that has the speci-
fied type can be obtained simply by adding a * to type.

Quzah.

No, it assumes that the next argument IS an int.
And if it isn't an int, then everything gets screwed up after that point.

va_arg just gets the next param, and uses the type to decide how big that parameter is.

Originally Posted by Salem

va_arg just gets the next param, and uses the type to decide how big that parameter is.

Size of the parameter is not the only concern. Generally, the type specified in the va_arg() usage has to match (or, more precisely, have an identical representation) the type of the actual argument, as there a type conversion tends to happen somewhere in the implementation of va_arg().

If the supplied argument was (say) a pointer that happens to be the same size as an int, using the result from va_arg(ap, int) gives undefined behaviour (since pointers rarely have the same representation as a signed int).

edit

edit.

thanks i think i get it now