C Language Preprocessor

In this tutorial, we will introduce the C preprocessor and learn how to use #include, #define, and conditional compilation with the help of examples. The C preprocessor is a macro preprocessor (allowing you to define macros) that can be transformed before compiling the program. These transformations can include header files, macro expansion, etc. All preprocessing instructions start with the # symbol.

Preprocessor example

Analyze the following examples to understand different instructions.

#define MAX_ARRAY_LENGTH　20

This instruction tells CPP to replace all MAX_ARRAY_LENGTH with 20. Use #define Define constants to enhance readability.

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

These instructions tell CPP to get fromSystem libraryObtain stdio.h and add text to the current source file. The next line tells CPP to get from the local directory. myheader.hand add content to the current source file.

#undef FILE_SIZE
#define FILE_SIZE　42

This instruction tells CPP to cancel the already defined FILE_SIZE and define it as 42.

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

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

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

This instruction tells CPP to execute the processing statements if DEBUG is defined. When compiling, if you pass -DDEBUG Switches, this instruction is very useful. It defines DEBUG, which you can turn on or off at any time during compilation.

Predefined macro

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:

#include <stdio.h>
main()
{
　　　printf("File　:%s\n", __FILE__);
　　　printf("Date　:%s\n", __DATE__);
　　　printf("Time　:%s\n", __TIME__);
　　　printf("Line　:%d\n", __LINE__);
　　　printf("ANSI　:%d\n", __STDC__);
}

When the above code (in the file test.c When the program is compiled and executed, it will produce the following results:

File　:test.c
Date　:Jun　2　2012
Time　:03:36:24
Line　:8
ANSI　:1

Preprocessor operator

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

Macro continuation operator (\)

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

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

String literal tokenization operator (#)

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

#include <stdio.h>
#define message_for(a, b) \"}}
　　　　printf(#a " and " #b ": We love you!\n")
int main(void)
{
　　　message_for(Carole, Debra);
　　　return 0;
}

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

Carole and Debra: We love you!

Token concatenation operator (##)

The token concatenation operator (##) within macro definitions merges two parameters. It allows two independent tokens to be combined into one token within macro definitions. For example:

#include <stdio.h>
#define tokenpaster(n) printf("token" #n " = %d", token##n)
int main(void)
{
　　　int token34　=　40;
　　　
　　　tokenpaster(34);
　　　return 0;
}

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

token34　=　40

How is this happening because this example will produce the following actual output from the compiler:

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

This example demonstrates that token##n will be concatenated to token34 in which, we useString literal tokenization operator (#)andToken concatenation operator (##).

defined() operator

Preprocessor defined Operators are used in constant expressions to determine if an identifier has been defined using #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 usage of the defined() operator:

#include <stdio.h>
#if !defined(MESSAGE)
　　　#define MESSAGE "You wish!"
#endif
int main(void)
{
　　　printf("This is the message: %s\n", MESSAGE);　　
　　　return 0;
}

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

This is the message: You wish!

Parameterized macro

CPP has a powerful feature that allows the use of 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 macros as follows:

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

Before using a macro with parameters, it is necessary to use #define Instruction definition. The parameter list is enclosed in parentheses and must be immediately followed by the macro name. There should be no space between the macro name and the left parenthesis. For example:

#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
　　　printf("10to2The maximum value between 0 and %d\n", MAX(10,　20));　　
　　　return 0;
}

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

10to2The maximum value between 0 and　20