c语言预处理的详细介绍_预处理文件解读-CSDN博客

#include<stdio.h>
#include<stdlib.h>
int main() {
	printf("file:%s ,line:%d ,date:%s ,time:%s \n", __FILE__, __LINE__, __DATE__, __TIME__);
	return 0;
}

#define

#define定义的标识符

语法：

#define name stuff

stuff可以有很多不同的类型。

#define MAX 100
#define LINE "You jump,I jump!" //内容为字符串
#define REG register //register为关键字，用更简短的单词来进行替换
#define do_foever for(;;) //用更形象的方式替换死循环
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜

//杠(续行符)。
#define PRINT printf("file:%s ,line:%d ,\
date:%s ,time:%s \n", __FILE__,\
__LINE__, __DATE__, __TIME__)

在define定义标识符的时候，最好不要加上；

因为stuff的内容会做一个替换，如果加上；，那么替换的内容就是 stuff；

#define 定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。

// 宏的声明方式：

#define name( parament-list ) stuff

其中，parament-list是一个由逗号隔开的符号表，会出现在后面的stuff中

需要注意的是：参数列表的左括号必须与name紧邻。如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

#include<stdio.h>
#define SQUARE(X) X*X
int main() {
	printf("%d\n", SQUARE(5));
    //相当于printf("%d\n", 5*5);
	return 0;
}

输出 25

那下面这条代码输出的会是什么呢？

printf("%d\n", SQUARE(5+1));

输出 11 。怎么不是36呢？让我们来替换一下，上述代码相当于：

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

所以在写宏的时候，最好该有的括号给齐。

#include<stdio.h>
#define SQUARE(X) (X)*(X)
int main() {
	printf("%d\n", SQUARE(5+1));
	return 0;
}

这才会输出 36。

但宏这样子写，就一定能保证每次使用，算的都是X的平方数吗？再看一看下面的代码。

printf("%lf\n", 1.0/SQUARE(5+1));

输出 1.000000

肯定不对吧。所以定义宏，最好按照下面的方式写：

#include<stdio.h>
#define SQUARE(X) ((X)*(X))
int main() {
	printf("%lf\n", 1.0/SQUARE(5+1));
	return 0;
}

再看一个加法的例子：

#include<stdio.h>
#define DOUBLE(X) ((X)+(X))
int main() {
	printf("%d\n", 2 * DOUBLE(7));
	return 0;
}

结论：用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

#define 替换规则

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

#define M 10
#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
	int m = MAX(2 + 3, M);
    //int m = MAX(2+3, 10);
    //替换成 ： int m = ((2+3)>(10)?(2+3):(10))
	printf("%d\n", m);
	printf("hello M");//#define 定义的标识符M，在字符串里面的是识别不了的
	return 0;
}

需要注意的是：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#和##

我们发现字符串是有自动连接的特点的：

printf("hello " "world!");

输出 hello world!

那么是不是可以考虑把参数插入到字符串中？

我们可以这样操作：

#define PRINT(FORMAT,VALUE) printf("the value is "FORMAT"\n",VALUE)

......

PRINT("%lf",10.2);

这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。

也可以利用#，把对应的宏参数转变成字符串

int i = 10;

#define PRINT(FORMAT, VALUE)\

printf("the value of " #VALUE "is "FORMAT "\n", VALUE);

......

PRINT("%d", i+3); // 产生了什么效果？

输出 the value of i+3 is 13

##的作用

##可以把位于它两边的符号合成一个符号。

#define CAT(A,B)  A##B

int main()
{
	int Class107 = 100;

	printf("%d\n", CAT(Class, 107));
    //等价于printf("%d\n", Class107);

	return 0;
}

带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候，对数据对象或文件的修改。

具有副作用的运算符：赋值运算符、递增运算符以及递减运算符。

下面代码输出的结果是什么？

#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);

经过替换，我们有：

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

输出 x=6 y=10 z=9

所以我们最好不要写带有副作用的宏参数。

宏与函数的对比

宏通常被应用于执行简单的运算。可这样一来，功能岂不是跟函数一样了？？请继续看接下来的文章，可能会让你对宏与函数的区别有了更清晰的认知。

对于那些简单的运算而言，虽然函数也能实现，但用宏更加优越。原因如下：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。

2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏适用于整形、长整型、浮点型等类型。宏是类型无关的。

但与函数相比，宏也有缺陷：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。比如一段宏50行，然后多次使用。

2. 宏是没法调试的。

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

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。（如前文所提及的括号问题）。

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

#include<stdio.h>
#include<stdlib.h>
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main() {
	//int* p1 = (int*)malloc(10 * sizeof(int));
	int* p2 = MALLOC(10, int);
    //预处理替换之后：int* p2 = (int*)malloc(10 * sizeof(int));
	return 0;
}

宏的命名规则

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。那我们平时的一个习惯是：

1. 把宏名全部大写

2. 函数名不要全部大写

但有例外，例如offsetof，它其实是个宏。

#undef

如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。#undef这条指令用于移除一个宏定义。

#undef MALLOC

条件编译

对于有些代码，需要根据某些条件，来决定用或不用。这时，就需要条件编译指令。使用逻辑与之前介绍过的分支语句一样，但不一样的是，选择不用的代码，预处理过后就直接被删除掉了，只有选择使用的那部分，会留下来。

条件编译指令：

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 OPTION1 unix_version_option1();

#endif

#ifdef OPTION2 unix_version_option2();

#endif

#elif defined(OS_MSDOS)

#ifdef OPTION2 msdos_version_option2();

#endif

#endif

单分支情况：

#include<stdio.h>
int main() {
#if 1 //为真值
//#if 2>3 恒为假
	printf("呵呵\n");
#endif
	return 0;
}

多分支情况：

#include<stdio.h>
int main() {
    #if 1>2
	printf("呵呵\n");
    #elif 2>4
	printf("嘿嘿\n");
    #else
	printf("哟~\n");
    #endif
	return 0;
}

判断是否被定义：

#include<stdio.h>
#define MAX 0
int main() {
    #if defined(MAX)
	printf("Yes\n");
    #endif
    #if !defined(MAX)
	printf("NO\n");
    #endif
	return 0;
}

输出 Yes

另一种写法：

#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;
}

这里的__DEBUG__并不需要是真值，只要定义了就可以。