1. 预定义符号

2. #define定义常量

3. #define定义宏

4. 带有副作⽤的宏参数

5. 宏替换的规则

6. 宏函数的对⽐

7. #和##

8. 命名约定

9. #undef

10. 命令⾏定义

11. 条件编译

12. 头⽂件的包含

13. 其他预处理指令

正文开始：

__FILE__ // 进⾏编译的源⽂件

__LINE__ // ⽂件当前的⾏号

__DATE__ // ⽂件被编译的⽇期

__TIME__ // ⽂件被编译的时间

__STDC__ // 如果编译器遵循 ANSI C ，其值为 1 ，否则未定义

举个例⼦：

printf ( "file:%s line:%d\n" , __FILE__, __LINE__);

# define name stuff

举个例⼦： 

#define MAX 1000
#define reg register //为 register这个关键字，创建⼀个简短的名字
#define do_forever for(;;) //⽤更形象的符号来替换⼀种实现
#define CASE break;case //在写case语句的时候⾃动把 break写上。
// 如果定义的 stuff过⻓，可以分成⼏⾏写，除了最后⼀⾏外，每⾏的后⾯都加⼀个反斜杠(续⾏符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \date:%s\ttime:%s\n" ,\__FILE__,__LINE__ , \__DATE__,__TIME__ )

if(condition)max = MAX;
elsemax = 0;

其中的 parament-list 是⼀个由逗号隔开的符号表，它们可能出现在stuff中。 

printf ( "%d\n" ,a + 1 * a + 1 );

这样就⽐较清晰了，由替换产⽣的表达式并没有按照预想的次序进⾏求值。

1 # define SQUARE(x) (x) * (x)

 这样预处理之后就产⽣了预期的效果：

printf ( "%d\n" ,(a + 1 ) * (a + 1 ) );

这⾥还有⼀个宏定义：

#define DOUBLE(x) (x) + (x) 

定义中我们使⽤了括号，想避免之前的问题，但是这个宏可能会出现新的错误。

int a = 5 ;

printf ( "%d\n" , 10 * DOUBLE(a));

printf ( "%d\n" , 10 * ( 5 ) + ( 5 ));

# define DOUBLE( x) ( ( x ) + ( x ) )

MAX宏可以证明具有副作⽤的参数所引起的问题。

# define MAX(a, b) ( (a) > (b) ? (a) : (b) )

...

x = 5 ;

y = 8 ;

z = MAX(x++, y++);

printf ( "x=%d y=%d z=%d\n" , x, y, z); // 输出的结果是什么？

1 z = ( (x++) > (y++) ? (x++) : (y++));  

2. 当预处理器搜索#define定义的

符号的时候，字符串常量的内容并不被搜索。

6. 宏函数的对⽐

宏通常被应⽤于执⾏简单的运算。

⽐如在两个数中找出较⼤的⼀个时，写成下⾯的宏，更有优势⼀些。

1 # define MAX(a, b) ((a)>(b)?(a):(b))

那为什么不⽤函数来完成这个任务？

原因有⼆：

1. ⽤于调⽤函数和从函数返回的代码可能⽐实际执⾏这个⼩型计算⼯作所需要的时间更多。所以宏⽐函数在程序的规模和速度⽅⾯更胜⼀筹。

2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使⽤。反之这个宏怎可以适⽤于整形、⻓整型、浮点型等可以⽤于 > 来⽐较的类型。宏是类型⽆关的。

和函数相⽐宏的劣势：

1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序的⻓度。

2. 宏是没法调试的。

3. 宏由于类型⽆关，也就不够严谨。

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

宏有时候可以做函数做不到的事情。⽐如：宏的参数可以出现类型，但是函数做不到。

# define MALLOC(num, type)\

(type )malloc(num sizeof(type))

...

// 使⽤

MALLOC( 10 , int ); // 类型作为参数

// 预处理器替换之后：

( int ) malloc ( 10 sizeof ( int ));

宏和函数的⼀个对⽐:

# define PRINT(n) printf( "the value of " #n " is %d" , n); 

printf ( "the value of ""a" " is %d" , a);  

运⾏代码就能在屏幕上打印：

the value of a is 10 

int int_max(int x, int y)
{return x>y?x:y;
}
float float_max(float x, float y)
{return x>yx:y;
}

//宏定义
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{ \return (x>y?x:y); \
}

GENERIC_MAX(int) //替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
int main()
{//调⽤函数int m = int_max(2, 3);printf("%d\n", m);float fm = float_max(3.5f, 4.5f);printf("%f\n", fm);return 0;
}

把宏名全部⼤写

函数名不要全部⼤写

# undef NAME

// 如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除。

#include <stdio.h>
int main()
{int array [ARRAY_SIZE];int i = 0;for(i = 0; i< ARRAY_SIZE; i ++){array[i] = i;}for(i = 0; i< ARRAY_SIZE; i ++){printf("%d " ,array[i]);}printf("\n" );return 0;
}

#include <stdio.h>
#define __DEBUG__
int main()
{int i = 0;int arr[10] = {0};for(i=0; i<10; i++){arr[i] = i;#ifdef __DEBUG__printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 #endif //__DEBUG__}return 0;
}

1.
#if 常量表达式//...
#endif
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1
#if __DEBUG__//..
#endif
2.多个分⽀的条件编译
#if 常量表达式//...
#elif 常量表达式//...
#else//...
#endif
3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
4.嵌套指令
#if defined(OS_UNIX)#ifdef OPTION1unix_version_option1();#endif#ifdef OPTION2unix_version_option2();#endif
#elif defined(OS_MSDOS)#ifdef OPTION2msdos_version_option2();#endif
#endif

12.2 嵌套⽂件包含

我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的

地⽅⼀样。

这种替换的⽅式很简单：预处理器先删除这条指令，并⽤包含⽂件的内容替换。

⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。

 test.c

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{return 0;
}

test.h

void test();
struct Stu
{int id;char name[20];
};

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容
#endif //__TEST_H__

或者  

# pragma once

就可以避免头⽂件的重复引⼊。

13. 其他预处理指令
#error
#pragma
#line
...
不做介绍，⾃⼰去了解。
#pragma pack()在结构体部分介绍。
参考《C语⾔深度解剖》学习