The preprocessor supports text macro replacement and function-like text macro replacement.

[edit]Syntax

[edit]Explanation

[edit]#define directives

The#define directives define theidentifier as a macro, that is they instruct the compiler to replace all successive occurrences ofidentifier withreplacement-list, which can be optionally additionally processed. If the identifier is already defined as any type of macro, the program is ill-formed unless the definitions are identical.

[edit]Object-like macros

Object-like macros replace every occurrence of a definedidentifier withreplacement-list. Version (1) of the#define directive behaves exactly like that.

[edit]Function-like macros

Function-like macros replace each occurrence of a definedidentifier withreplacement-list, additionally taking a number of arguments, which then replace corresponding occurrences of any of theparameters in thereplacement-list.

The syntax of a function-like macro invocation is similar to the syntax of a function call: each instance of the macro name followed by a ( as the next preprocessing token introduces the sequence of tokens that is replaced by the replacement-list. The sequence is terminated by the matching ) token, skipping intervening matched pairs of left and right parentheses.

The number of arguments must be the same as the number of arguments in the macro definition (parameters) or the program is ill-formed. If the identifier is not in functional-notation, i.e., does not have parentheses after itself, it is not replaced at all.

Version (2) of the#define directive defines a simple function-like macro.

Version (3) of the#define directive defines a function-like macro with variable number of arguments. The additional arguments can be accessed using__VA_ARGS__ identifier, which is then replaced with arguments, supplied with the identifier to be replaced.

Version (4) of the#define directive defines a function-like macro with variable number of arguments, but no regular arguments. The arguments can be accessed only with__VA_ARGS__ identifier, which is then replaced with arguments, supplied with identifier to be replaced.

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)F(a, b, c)// replaced by f(0, a, b, c)F()// replaced by f(0) #define G(X, ...) f(0, X __VA_OPT__(,) __VA_ARGS__)G(a, b, c)// replaced by f(0, a, b, c)G(a,)// replaced by f(0, a)G(a)// replaced by f(0, a) #define SDEF(sname, ...) S sname __VA_OPT__(= { __VA_ARGS__ })SDEF(foo);// replaced by S foo;SDEF(bar,1,2);// replaced by S bar = { 1, 2 };

Note: if an argument of a function-like macro includes commas that are not protected by matched pairs of left and right parentheses (such asmacro(array[x= y, x+1]) oratomic_store(p,(struct S){ a, b});), the comma is interpreted as macro argument separator, causing a compilation failure due to argument count mismatch.

[edit]# and## operators

In function-like macros, a# operator before an identifier in thereplacement-list runs the identifier through parameter replacement and encloses the result in quotes, effectively creating a string literal. In addition, the preprocessor adds backslashes to escape the quotes surrounding embedded string literals, if any, and doubles the backslashes within the string as necessary. All leading and trailing whitespace is removed, and any sequence of whitespace in the middle of the text (but not inside embedded string literals) is collapsed to a single space. This operation is called “stringification”. If the result of stringification is not a valid string literal, the behavior is undefined.

#define showlist(...) puts(#__VA_ARGS__)showlist();// expands to puts("")showlist(1,"x",int);// expands to puts("1, \"x\", int")

A## operator between any two successive identifiers in thereplacement-list runs parameter replacement on the two identifiers and then concatenates the result. This operation is called “concatenation” or “token pasting”. Only tokens that form a valid token together may be pasted: identifiers that form a longer identifier, digits that form a number, or operators+ and= that form a+=. A comment cannot be created by pasting/ and* because comments are removed from text before macro substitution is considered. If the result of concatenation is not a valid token, the behavior is undefined.

Note: Some compilers offer an extension that allows## to appear after a comma and before__VA_ARGS__, in which case the## does nothing when__VA_ARGS__ is non-empty, but removes the comma when__VA_ARGS__ is empty: this makes it possible to define macros such asfprintf(stderr, format,##__VA_ARGS__).

The order of evaluation of# and## operators is unspecified.

[edit]#undef directive

The#undef directive undefines theidentifier, that is it cancels the previous definition of theidentifier by#define directive. If the identifier does not have an associated macro, the directive is ignored.

[edit]Predefined macros

The following macro names are predefined in any translation unit:

The following additional macro names may be predefined by an implementation:

The values of these macros (except for__FILE__ and__LINE__) remain constant throughout the translation unit. Attempts to redefine or undefine these macros result in undefined behavior.

[edit]Example

#include <stdio.h> // make function factory and use it#define FUNCTION(name, a) int fun_##name(int x) { return (a) * x; }FUNCTION(quadruple,4)FUNCTION(double,2)#undef FUNCTION #define FUNCTION 34 #define OUTPUT(a) puts( #a ) int main(void){printf("quadruple(13): %d\n", fun_quadruple(13));printf("double(21): %d\n", fun_double(21));printf("%d\n", FUNCTION);    OUTPUT(billion);// note the lack of quotes}

quadruple(13): 52double(21): 4234billion

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C standards.

[edit]References

[edit]See also

• In other languages

• العربية
• Česky
• Deutsch
• Español
• Français
• Italiano
• 日本語
• 한국어
• Polski
• Português
• Русский
• Türkçe
• 中文