C Preprocessor

C preprocessor (CPP)is an independent phase in the compilation process, inBefore actual compilationText processing of source code. Main features include:

• Macro expansion
• File inclusion
• Conditional Compilation
• Special directive handling

C PreprocessorIt is not a component of the compiler, but it is a separate step in the compilation process.

In short, the C preprocessor is nothing more than a text replacement tool, which instructs the compiler to complete the required preprocessing before actual compilation.

We will abbreviate the C Preprocessor as CPP.

All preprocessor commands begin with a hash sign#The beginning. It must be the first non-whitespace character. For readability, preprocessor directives should start from the first column.

All important preprocessor directives are listed below:

Preprocessor examples

Analyze the following examples to understand the different directives.

#define MAX_ARRAY_LENGTH 20

This directive tells CPP to define MAX_ARRAY_LENGTH as 20. Use#defineDefine constants to enhance readability.

#include <stdio.h>
#include "myheader.h"

These directives tell CPP toSystem libraryget stdio.h from it, and add the text to the current source file. The next line tells CPP to get it from the local directorymyheader.h, and add content to the current source file.

#undef  FILE_SIZE
#define FILE_SIZE 42

This directive tells CPP to undefine the defined FILE_SIZE and define it as 42.

#ifndef MESSAGE
   #define MESSAGE "You wish!"
#endif

This directive tells CPP to define MESSAGE only when MESSAGE is not defined.

#ifdef DEBUG
   /* Your debugging statements here */
#endif

This directive tells CPP to execute the processing statements if DEBUG is defined. At compile time, if you pass the switch to the gcc compiler,-DDEBUGthis directive is very useful. It defines DEBUG, and you can enable or disable debugging at any time during compilation.

Best practice recommendations

1. Macro naming：

   • Use all uppercase letters and underscores to name macros
   • Example:#define MAX_SIZE 100

2. Notes on function-like macros：

   • Every parameter and the entire expression should be enclosed in parentheses.
   • Avoid using arguments with side effects (e.g.SQUARE(x++)）

3. Header file protection：

   #ifndef MY_HEADER_H
   #define MY_HEADER_H
   /* 头文件内容 */
   #endif

4. Conditional compilation debugging：

   #ifdef DEBUG
   #define DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
   #else
   #define DEBUG_PRINT(fmt, ...)
   #endif
   

5. Cross-Platform Development：

   #if defined(_WIN32)
   // Windows特定代码
   #elif defined(__linux__)
   // Linux特定代码
   #elif defined(__APPLE__)
   // macOS特定代码
   #endif
   

Predefined macros

ANSI C defines many macros. You can use these macros in programming, but you cannot directly modify these predefined macros.

Let's try the following example:

When the above code (in filetest.cin) is compiled and executed, it produces the following results:

当前文件: predef_macros.c
编译日期: Jul 5 2023
编译时间: 14:30:45
当前行号: 13
ANSI标准: 1

[调试信息] predef_macros.c (第16行) 编译于 Jul 5 2023 14:30:45

Preprocessor operators

The C preprocessor provides the following operators to help you create macros:

Macro continuation operator (\)

A macro is usually written on a single line. But if a macro is too long to fit on a single line, use the line continuation operator (\). For example:

#define  message_for(a, b)  \
    printf(#a " and " #b ": We love you!\n")

Stringizing operator (#)

In a macro definition, when you need to convert a macro parameter to a string constant, use the stringizing operator (#). The operator used in a macro has a specific parameter or parameter list. For example:

When the above code is compiled and executed, it produces the following results:

Carole and Debra: We love you!

Token-pasting operator (##)

The token-pasting operator (##) in a macro definition merges two parameters. It allows two separate tokens in the macro definition to be merged into one token. For example:

When the above code is compiled and executed, it produces the following results:

token34 = 40

This is how it happens, because this example will produce the following actual output from the compiler:

printf ("token34 = %d", token34);

This example demonstrates that token##n concatenates into token34; here, we usedStringizing operator (#)andToken-pasting operator (##)。

The defined() operator

PreprocessordefinedThe operator is used in constant expressions to determine whether an identifier has already been defined with #define. If the specified identifier is defined, the value is true (non-zero). If the specified identifier is not defined, the value is false (zero). The following example demonstrates the use of the defined() operator:

When the above code is compiled and executed, it produces the following results:

Here is the message: You wish!

Parameterized macros

A powerful feature of CPP is the ability to use parameterized macros to simulate functions. For example, the following code calculates the square of a number:

int square(int x) {
   return x * x;
}

We can rewrite the above code using a macro as follows:

#define square(x) ((x) * (x))

Before using a macro with parameters, you must use#definea directive to define it. The parameter list is enclosed in parentheses and must immediately follow the macro name. No whitespace is allowed between the macro name and the left parenthesis. For example:

When the above code is compiled and executed, it produces the following results:

Max between 20 and 10 is 20