[Main]
Title=Macros with a Variable Number of Arguments

[Top]
In the ISO C standard of 1999, a macro can be declared to accept a
variable number of arguments much as a function can.  The syntax for
defining the macro is similar to that of a function.  Here is an
example:
<PRE>#define lprintf(format, ...) fprintf (log, format, __VA_ARGS__)
</PRE>
Here <CODE>...</CODE> is a <U>variable argument</U>.  In the invocation of
such a macro, it represents the zero or more tokens until the closing
parenthesis that ends the invocation, including any commas.  This set of
tokens replaces the identifier <CODE>__VA_ARGS__</CODE> in the macro body
wherever it appears.
For more information, see <A HREF="$$INFOLINK(cpp/SEC13)">Variadic Macros</A>.
<BR><BR>
GCC has long supported variadic macros, and used a different syntax that
allowed you to give a name to the variable arguments just like any other
argument.  Here is an example:
<PRE>#define lprintf(format, args...) fprintf (stderr, format, args)
</PRE>
This is in all ways equivalent to the ISO C example above, but arguably
more readable and descriptive.
<BR><BR>
GNU CPP has two further variadic macro extensions, and permits them to
be used with either of the above forms of macro definition.
<BR><BR>
In standard C, you are not allowed to leave the variable argument out
entirely; but you are allowed to pass an empty argument.  For example,
this invocation is invalid in ISO C, because there is no comma after
the string:
<PRE>lprintf (&quot;A message&quot;);
</PRE>
GNU CPP permits you to completely omit the variable arguments in this
way.  In the above examples, the compiler would complain, though since
the expansion of the macro still has the extra comma after the format
string.
<BR><BR>
To help solve this problem, CPP behaves specially for variable arguments
used with the token paste operator, <CODE>##</CODE>.  If instead you write
<PRE>#define lprintf(format, ...) fprintf (log, format, ## __VA_ARGS__)
</PRE>
and if the variable arguments are omitted or empty, the <CODE>##</CODE>
operator causes the preprocessor to remove the comma before it.  If you
do provide some variable arguments in your macro invocation, GNU CPP
does not complain about the paste operation and instead places the
variable arguments after the comma.  Just like any other pasted macro
argument, these arguments are not macro expanded.
