Variable arguments in C

Is there a way to read/access variable arguments like we read command line arguments from argv[]?

I'm aware of the va_arg way of doing it but just wondering if something like "argv" exists for this?

The only facility the C standard provides for accessing variable arguments is the va_arg method.

In general, it would be impossible (barring some gross extension to the language) for there to be any sort of va_arg[i] method of accessing variable arguments since va_arg[i] must have one fixed type but variable arguments can have any complete object type.

A C implementation might implement the <stdarg.h> features by organizing arguments into memory serially, and then it could be possible to access that memory yourself, including accessing it as an array of all the variable arguments have the same type. However, the means for doing so would not only not be portable to other C implementations but generally would not be supported by the specific C implementation.

Actually, yes there's a way

...with macro tricks.

#include <stdio.h>

// foo is a macro that'll take multiple strings and pass them to _foo
#define foo(...) _foo( sizeof((char *[]){__VA_ARGS__}) / sizeof(char *), (char *[]){__VA_ARGS__})

void _foo(int argc, char *argv[])
{
	printf("argc: %d\n", argc);
	for (int i = 0; i < argc; i++)
	{
		printf("argv[%d]: %s\n", i, argv[i]);
	}
}

int main(void)
{
	foo("Hello", "World");
}

How it works

It uses:

• ... and __VA_ARGS__: the syntax for variadic arguments in macros
• (char *[]){/*...*/}: a compound literal to create a array of strings
• sizeof(array) / sizeof(elem): a trick to get the number of elements in an array

The macro foo creates two arrays from the variadic parameters. The first array is used in the size trick, and passed to argc. The second is directly passed to argv.

Two of the above points have already been pointed out in the comments by @Brian61354270 and @Cubic, it was just a matter of putting the whole thing together. Especially @Cubic, who showed the same way but without a macro.

A few notes

• Unlike with va_arg, this technique can only be used when you have arguments of the same type.
• This uses a macro. Often, it implies that the macro arguments might be evaluated multiple times. Here it looks like the arguments are evaluated twice, but sizeof doesn't evaluate. So calling foo(bar()) will only call bar once. (Which is pretty good, that's what we want)
• It doesn't behave exactly like the main's argc/argv. For starters, I didn't put NULL at the end of argv. That's trivial to add though.

Are you perhaps referring to the way that functions like printf can take different arguments at different times?

printf is an example of a variadic function, and is declared as:

printf(char* format, ...); 

Where the ... means the following arguments can be of any type, and there can be any number of them.

These are processed by the caller using type va_list and macros va_start, va_arg and va_end, all defined in header file <stdarg.h>.

There are plenty of examples online that explain how this is used.