Replacing text macros - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Replacing text macros

From cppreference.com
< c‎ | preprocessor

The preprocessor supports text macro replacement. Function-like text macro replacement is also supported.

### [edit] Syntax

`#define` identifier replacement-list | (1) |
`#define` identifier`(` parameters `)` replacement-list | (2) |
`#define` identifier`(` parameters`, ... )` replacement-list | (3) | (since C99)
`#define` identifier`( ... )` replacement-list | (4) | (since C99)
`#undef` identifier | (5) |

### [edit] Explanation

#### [edit] `#define` directives

The `#define` directives define the identifier as macro, that is instruct the compiler to replace all successive occurrences of identifier with replacement-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 defined identifier with replacement-list. Version (1) of the `#define` directive behaves exactly like that.

##### [edit] Function-like macros

Function-like macros replace each occurrence of defined identifier with replacement-list, additionally taking a number of arguments, which then replace corresponding occurrences of any of the parameters in the replacement-list. The number of arguments must be the same as the number of arguments in 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.

#### [edit] `#` and `##` operators

In function-like macros, a `#` operator before an identifier in the replacement-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.

A `##` operator between any two successive identifiers in the replacement-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.

#### [edit] `#undef` directive

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

### [edit] Predefined macros

The following macro names are predefined in any translation unit.

__STDC__ | expands to the integer constant 1. This macro is intended to indicate a conforming implementation (macro constant)
__STDC_VERSION__ (C99) | denotes the revision of the standard that is being used (macro constant)
__STDC_HOSTED__ (C99) | expands to the integer constant 1 if the implementation is hosted (runs under an OS), ​0​ if freestanding (runs without an OS) (macro constant)
__FILE__ | expands to the name of the current file, as a character string literal, can be changed by the #line directive (macro constant)
__LINE__ | expands to the source file line number, an integer constant, can be changed by the #line directive (macro constant)
__DATE__ | expands to the date of translation, a character string literal of the form "Mmm dd yyyy". The name of the month is as if generated by asctime() (macro constant)
__TIME__ | expands to the time of translation, a character string literal of the form "hh:mm:ss", as in the time generated by asctime() (macro constant)

The following additional macro names may be predefined by the implementations.

__STDC_ISO_10646__ (C99) | expands to an integer constant of the form `yyyymmL`, if wchar_t uses Unicode, the date indicates the latest revision of Unicode supported (macro constant)
__STDC_IEC_559__ (C99) | expands to 1 if IEC 60559 is supported (macro constant)
__STDC_IEC_559_COMPLEX__ (C99) | expands to 1 if IEC 60559 complex arithmetic is supported (macro constant)
__STDC_UTF_16__ (C11) | expands to 1 if char16_t use UTF-16 encoding (macro constant)
__STDC_UTF_32__ (C11) | expands to 1 if char32_t use UTF-32 encoding (macro constant)
__STDC_MB_MIGHT_NEQ_WC__ (C11) | expands to 1 if wide character encoding of the basic character set may not equal their narrow encoding (macro constant)
__STDC_ANALYZABLE__ (C11) | expands to 1 if implementation conform to the specifications defined in C11 Annex L (macro constant)
__STDC_LIB_EXT1__ (C11) | expands to an integer constant if implementation support bounds-checking interfaces (an extension defined in C11 Annex K) (macro constant)
__STDC_NO_ATOMICS__ (C11) | expands to 1 if implementation does not support atomic types (macro constant)
__STDC_NO_COMPLEX__ (C11) | expands to 1 if implementation does not support complex types (macro constant)
__STDC_NO_THREADS__ (C11) | expands to 1 if implementation does not support thread (macro constant)
__STDC_NO_VLA__ (C11) | expands to 1 if implementation does not support variable length arrays (macro constant)

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.

Note: in the scope of every function body, there is a special function-local predefined variable named __func__(since C99), defined as a static character array holding the name of the function in implementation-defined format. It is not a preprocessor macro, but it is used together with `__FILE__` and `__LINE__`, e.g. by assert.

### [edit] Example

Run this code

    #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(million);               //note the lack of quotes
    }

Output:

    quadruple(13): 52
    double(21): 42
    34
    million

C++ documentation for Replacing text macros

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=c/preprocessor/replace&oldid=71849"