Summary of the usage of macro definitions

Overview

A macro definition is a code fragment with a given name. When we use this name, the preprocessor will automatically replace it with the content of the macro definition. There are two types of macro definitions, one is object-like macro definition, which is equivalent to a data object when used; the other is function-like, which is like calling a function when used.

The content of the macro definition can be arbitrary, even C keywords (unavailable content special case [preprocessing command]defined,[c++ named operators]and_eq,bitand,bitor,compl,not,not_eq,or,or_eq,xor, xor_eq)

Macro expansion will make the source program longer, but the macro expansion occurs during the compilation process and does not take up the running time, only the compilation time.

Because macro expansion occurs during the preprocessing stage, no memory will be allocated.
When the Macro Replacement Occurs

The process of compiling c source program:

    Pre-
    compile
    assembly
    link

The preprocessing produces the output of the compiler, and the functions are as follows. The
file contains

Expand the content contained in #include to the body of the file, that is, find the .h file, and expand it to the location of #include at the same time.
Conditional compilation

According to compilation commands such as #if and #ifdef, part of the source program file is included, partly excluded, and the excluded ones are generally converted to blank lines.
Macro expansion

Expand the call to the macro into the corresponding macro definition
object-like macro definition
form

Normal form: #define <macro name> <string>

#define is followed by the name of the code segment defined by the macro, and then the token sequence represented by the macro name

Generally speaking, we use object-like macro definitions to give a symbol instead of numeric constants

例子: #define BUFFER_SIZE 1024

The macro name here is BUFFER_SIZE, and the token sequence to be replaced is 1024. Then when you use BUFFER_SIZE, the preprocessor will expand it so that the compiler will treat it as 1024 when processing

For example, the source code foo = (char*)malloc(BUFFER_SIZE), after being processed by the preprocessor, the compiler equates it to foo = (char*)malloc(1024).

usage

Generally speaking, the macro name is written in all capital letters (conventional, easy to read)

The #define command will stop at the end of the line. If you want to act on multiple lines at the same time, you need to add \ at the end, and pay attention not to add blanks such as spaces after \, just line breaks

E.g

    #define NUMBERS 1, \
                   2, \
                   3
        1
        2
        3

Equivalent to

#define NUMBERS 1, 2, 3
1

There are almost no restrictions on the content of the string defined by the macro (you need to ensure the balance of the parentheses)

Since the C preprocessor is sequential when processing the program, the macro definition starts from its defined position.

Macro definitions can be nested definitions, which means that if another macro definition name is encountered during replacement, the replacement will continue

In other words

    #define A B
    #define B 1
        1
        2

In the preprocessing, A ⟶ BA\longrightarrow BA⟶B, and then continue to check whether BBB is a macro name, replace B ⟶ 1 B\longrightarrow1 B⟶1, and replace A with 1 after the final replacement. It should be noted that when nesting definitions, if a certain macro name that has been checked is encountered during recursive checking, it will not continue to expand, thus avoiding recursive calls.

doubt

An article I read thinks

#define A B
#define B 1

1
2

versus

#define B 1
#define A B

1
2

There will be differences, the difference is that in the latter definition method, A will always be equal to the current effective value of B.

The result of my experiment is that both can be equal to the current effective value of B. I don’t understand what the article means. The concept of
self-referential macros

A self-referencing macro means that the name of the macro appears in its own macro definition. For example #define foo(4 + foo)

The rule of self-referencing macros In order to avoid endless recursive calls, calls such as (4+(4+(4+(4+foo)))) are generated, and it is forbidden to replace a macro name that has appeared again, that is Say that the above definition will only produce 4+foo.

Indirect self-referencing macros such as

#define x (4 + y)
#define y (2 * x)

1
2

Also follow the above rules, do not replace a macro name that has already appeared.
usage

Usually self-referencing macros directly

#define EPERM EPERM

Here EPERM is a defined quantity, so the code after #ifdef EPERM will run successfully.
function-like macro definition
concept
without parameters

Like #define <macro name>(<parameter list>) <macro body>

That is, a pair of parentheses must be immediately followed by the macro name.

When used, it must also be followed by a pair of parentheses, otherwise no replacement

In other words, after foo is preprocessed, it is still foo, and only foo() will be replaced with <macro body>

If there is a blank character (space, tab, etc.) between the macro name and the parentheses when defining it, such as #define test () my(), then what you define at this time is an object-like macro definition, for test It will be replaced with () my(), and test() will be replaced with () my()(). Note that it is not a function-like macro definition, and the parentheses after test() will not disappear.
With parameters

Those with parameters still have to follow the above rules, the difference is that the parameters are placed in parentheses immediately after the macro name, just like a real function.

For example #define <macro name>(<parameter list>) <macro body>

Note that the parameters in the parameter list must be valid c identifiers, separated by,
Usage

When you define a function-like macro definition such as #define min(X,Y) ((X) <(Y)? (X): (Y)), to call it, you only need to use the macro name followed by parameter list. Note that the number of parameters when you call should be exactly the same as the number of parameters in the macro definition.

For example, min(a,b) is equivalent to the use of ((a) <(b)? (A): (b)) such a ternary operator. The parameter list uses, as the delimiter, and () must appear in pairs. At the same time, **(,) in parentheses is not used as a separator**, that is to say, min((a,b)) actually you only pass A parameter (a, b), but there are no such requirements and rules for square brackets [] and curly brackets, they do not have to appear in pairs, and it does not affect the function as a separator, such as min([a,b]) Two parameters [a and b] are passed.

At the same time, the parameters defined by the function-like macro must have been completely replaced by the macro. That is to say, if you call min(min(a,b),c) and pass two parameters min(a,b),c, first Macro substitution for these two parameters, then min(a,b) will also become ((a) <(b)? (A): (b)), and then pass in this form.

During the parameter transfer process of the macro definition, whitespace is allowed to be the parameter passed, but no matter what kind of whitespace, it is considered as a pure whitespace during the transfer process, even if it turns out to be 5 spaces, it is only considered as a parameter. Such as calling min (, b) is passed two parameters and b, macro substitution result is (() <(b) ( ):? (B))
Notes

In <macro body>, if you add "" to the parameter, the parameter will not be replaced

E.g

#define foo(x) x,"x"
1

The call is foo(bar), replaced with bar, "x", and the x in "x" is not treated as a parameter.

Special usage
stringification
concept

Use # to change the parameter x into the corresponding string

Demo

#define TOSTRING(X) #x, apply this macro definition, and the final replacement will be a string.

For example, TOSTRING(x==0), the resulting replacement is "x==0"

Precautions

It should be noted that for the #stringified parameters, there is no need to perform macro expansion and substitution, but directly substitute

    #define A B
    TOSTRING(A)
        1
        2

The replacement produced here is "A", not "B", because stringification is a direct replacement.

#Stringification is not simply adding "" on both sides of the original parameters, but turning the characters that need to be escaped into escape characters.

For example, when the parameter is p = "foo\n"; the resulting string is "p = \"foo\\n\";|.

If there are whitespace characters in it, the whitespace at the beginning and the end will be discarded when it is converted into a string, and the middle will become a space.

In this way, the output string can be connected with the surrounding string to be called a long string

For example: #define TOSTRING(X) "test" #X "temp", assuming the parameter is p = "foo\n", then the final string will be "testp = \"foo\\n\temp";|

Token concatenation
concept

Use ## to connect the two tokens together. The token here can be the content of the macro body or the parameter.

The usage method is as follows: A##B. If A and B are both the contents of the macro body, then the content after the connection must be a valid c content. For example, characters like x##+ are not allowed to exist, of course x##+5 Can exist.
Precautions

The connection function of ## also takes precedence over macro expansion, that is, the ## operator is called first.
A blank character of any length can be placed between ## and its operand, but the ## operator cannot be placed at either end of the macro body. Obviously there will be no operation if ## is connected with a blank character

Variable macro definition
concept

The function-like macro definition can also not fix the number of parameters, and replace all parameters with a special identifier.

例如#define eprintf(...) fprintf(stderr,__VA_ARGS__)

The inside... means that the parameters in eprintf are variable, all of which are used to replace __VA_ARGS__, and __VA_ARGS__ is a reserved keyword, do not use it in other places, it is specifically used to replace variable parameters.

So when eprintf("%s:%d",input_file,lineno) is used, it will be replaced by fprintf(stderr,"%s:%d",input_file,lineno).

It is also possible to add a custom name to the variable parameter. It is only allowed to write a custom name directly before..., for example #define eprintf(st...) fprintf(stderr,st), where st is Custom name.
Special usage

Variable parameters and fixed parameters can exist at the same time, such as #define eprintf(format, ...) fprintf(stderr,format,__Va_ARGS__). Under the old compiler, at least two parameters must be provided, one for format and one for .... And the second parameter cannot be empty

Summary of the usage of macro definitions

Guess you like