• 【C/C++内功心法】剖析预处理过程，详解预处理指令，提升C/C++内功

    文章目录

    前言

    一、预定义符号

    二、#define

    1 #define 定义标识符

    2 #define 定义宏

    3 #define 替换规则

    4 #和##

    5 带副作用的宏参数

    总结

    前言

    大家好啊，我是不一样的烟火a，今天我将会为大家详细讲解预处理指令。虽然本文章读完后不能让大家代码写得飞起，但是预处理这个过程是十分重要的，其中的很多指令也是经常被考到，你了解了它，它将会大幅提升你的C/C++内功，让你学编程更加的容易。

    一、预定义符号

    注意：下面这些预定义符号都是语言内置的，可以直接拿来用。

    1. __FILE__      // 进行编译的源文件
    2.  
    3. __LINE__      // 文件当前的行号
    4.  
    5. __DATE__      // 文件被编译的日期
    6.  
    7. __TIME__      // 文件被编译的时间
    8.  
    9. __STDC__      // 如果编译器遵循ANSI C，其值为1，否则未定义
    10.  
    11. __func__      // 获取当前所在函数

    举例：

    1. #include
    2.  
    3. int main()
    4. {
    5. 	printf("name: %s, file: %s, line: %d, date: %s, time: %s\n", __func__, __FILE__, __LINE__, __DATE__, __TIME__);
    6.  
    7. 	return 0;
    8. }

    f6cf69f1b07d40249d2cd08516f929d6.png

    预定义符号的作用

    • 我们可以将上面这些文件的信息写到日志里面，如果程序出现错误，我们可以很好的定位到是哪个文件的哪个函数出错了，并且知道文件是在什么时候编译的。

    举例：

    1. #include
    2.  
    3. int main()
    4. {
    5. 	FILE* pf = fopen("log.txt", "a"); // 打开log.txt这个文件
    6.  
    7. 	if (pf == NULL)
    8. 	{
    9. 		return 1;
    10. 	}
    11. 	for (int i = 0; i < 10; ++i)
    12. 	{
    13. 		// 将所有文件信息写入log.txt文件
    14. 		fprintf(pf, "name: %s, file: %s, line: %d, date: %s, time: %s, i=%d\n", __func__, __FILE__, __LINE__, __DATE__, __TIME__, i);
    15. 	}
    16.  
    17. 	return 0;
    18. }

    我们打开log.txt文件，这时就将所有的文件信息都写了进来。

    0c971250ec4b408697d7530202144e14.png

    __STDC__ 预定义符号

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

    举例：

    1. int main()
    2. {
    3. 	printf("%d\n", __STDC__);
    4.  
    5. 	return 0;
    6. }

    在Windows的vs2019下

    • 编译器报错：未定义标识符“__STDC__”
    • 说明vs2019不遵循ANSI C

    2b9680b8c64c468390aec799dfbbbb7e.png

    在Linux的gcc下

    • 打印出来__STDC__的值为1
    • 说明gcc遵循ANSI C

    4cb0980cfb844a0cbaceebe98ebde77b.png

    ad52f163820a470181918381696e92ed.png

     二、#define

    1 #define 定义标识符

    语法：

    #define name stuff

    功能：

    • 在预处理阶段，将代码中所有的name替换成stuff。

    举例：

    1. #define NUM 666
    2. #define STR "hello"
    3.  
    4. int main()
    5. {
    6. 	int num = NUM;
    7. 	char* str = STR;
    8.  
    9. 	return 0;
    10. }

    在预处理阶段，上面的代码将会被替换成：

    由于我们定义的标识符已经被替换了，所以替换后，#define 定义标识符将会被删除。

    1. int main()
    2. {
    3. 	int num = 666;
    4. 	char* str = "hello";
    5.  
    6. 	return 0;
    7. }

    怎么验证？

    • 点击视图，然后打开解决方案资源管理器。

    87dc5409100b4f8ebad21f1ac8f85432.png

    •  右击此处。

    76fca208655a40a0888dac1724430d3f.png

    • 点击属性。

    db20ff74453e4de0b181759940c54c98.png

    •  点击C/C++，然后进入预处理器，将预处理到文件这里的选项改成“是”

    2722ee9d0d7042b99a7625e6f1470aec.png

    • 将当前文件编译一下，然后去当前路径下的Debug文件夹里面可以找到一个test.i文件（这就 是预处理完后生成的文件），然后将其打开。

    f44a996818194bcf9ce966a8c0129f8b.png

    fc9acf63883e40a2bc3b6892c2ca1b2e.png

    •  现在就可以看到替换前后的区别了。

    0cfed2f63cf04c7aa0eecf3fd1813542.png

     提问：

    • 在define定义标识符的时候，要不要在最后加上分号 " ; " ?
    • 答案是不用。

    如果我们在刚刚define定义标识符的最后加上" ; "  ，那么预处理后的结果将会是下面这样，这就会出现语法错误。

    15ef1a2725104dd8873a5f55fb8213b3.png

    当然define还可以定义其他标识符，可以是个关键字，也可以是一段代码。

    1. #define reg register           //为 register这个关键字，创建一个简短的名字
    2. #define do_forever for(;;)     //用更形象的符号来替换一种实现
    3. #define CASE break;case        //在写case语句的时候自动把 break写上。
    4.  
    5. // 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
    6. #define DEBUG_PRINT printf("file:%s\tline:%d\t \
    7.                           date:%s\ttime:%s\n" ,\
    8.                             __FILE__,__LINE__ ,\
    9.                              __DATE__,__TIME__ )

    2 #define 定义宏

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

    宏的申明方式：

    • #define name( parament-list ) stuff
    • 其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

    注意：

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

    举例：

    1. // 用于求两数中的较大值 
    2. #define MAX(x, y) (x > y ? x : y)
    3.  
    4. int main()
    5. {
    6. 	int a = 10;
    7. 	int b = 20;
    8. 	int c = MAX(a, b);
    9.     printf("%d\n", c);
    10.  
    11. 	return 0;
    12. }

    替换后的结果为：

    80277e0dc9e940e8bcef0f349a0d966c.png

     注意：如果你想运行当前代码，需要将刚才的设置改回来才行，因为经过刚才的设置后，编译器将代码预处理完就会停下来。

    a28786cc330c473a8f0525e4096c196c.png

    刚才代码的运行结果。

    4289e726a5af4796bc83f87cf23042ae.png

     注意：定义宏的时候必要的括号不能少，因为宏的本质还是替换。

    举例：

    我们写一个求平方的宏：

    #define SQUARE( x ) x * x

    这个宏接收一个参数 x ，

    如果在上述声明之后，你把

    SQUARE( 5 );

    置于程序中，预处理器就会用下面这个表达式替换上面的表达式：

    5 * 5

    注意： 这个宏存其实在一个问题，观察下面的代码段：

    1. int a = 5;
    2. printf("%d\n" ,SQUARE( a + 1) );

    乍一看，你可能觉得这段代码将打印36这个值。 事实上，它将打印11，为什么？

    替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了：

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

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

    解决办法：在宏定义上加上两个括号，这个问题便轻松的解决了：

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

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

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

    这里还有一个宏定义：

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

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

    1. int a = 5;
    2. printf("%d\n" ,10 * DOUBLE(a));

    这将打印什么值呢？

    看上去，好像打印100，但事实上打印的是55，我们发现替换之后：

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

    乘法运算先于宏定义的加法，所以出现了55的结果。

    解决办法：在宏定义表达式两边加上一对括号就可以了：

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

    所以我们这里就可以将上面写的求较大值的宏优化一下。

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

    提示：

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

    3 #define 替换规则

    在程序中扩展#define定义符号和宏时，需要涉及以下几个步骤：

    1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
    2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
    3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

    举例：

    1. #define DOUBLE(x) ((x) + (x))
    2. #define NUM 66
    3.  
    4. int main()
    5. {
    6. 	int a = DOUBLE(NUM);
    7.  
    8. 	return 0;
    9. }

    这里就会先将：

    int a = DOUBLE(NUM);

    替换成：

    int a = DOUBLE(66);

    然后再替换成：

    int a = ((66) + (66));

    注意：

    • 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
    • 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

    举例：

    这里的NUM将不会被替换。

    1. #define NUM 66
    2.  
    3. int main()
    4. {
    5. 	printf("NUM is a macro\n");
    6.  
    7. 	return 0;
    8. }

    4 #和##

    我们先来看一段代码：

    1. int main()
    2. {
    3. 	int a = 10;
    4. 	printf("the value of a is %d\n", a);
    5.  
    6. 	int b = 20;
    7. 	printf("the value of b is %d\n", b);
    8.  
    9. 	return 0;
    10. }

    运行结果：

    1df9e9df2365428caa09c2893041f99d.png

    • 我们发现上面的两行代码十分是相似，运行的结果也只有两处不同，那么我们可以把刚刚那两行代码（printf那两行）封装成一个函数吗？这样我们就不用每打印一个变量，都要单独写一个printf函数了。
    • 答案是可以，但是十分的复杂，使所以这时就需要用我们的宏了。

    但是我们知道，宏是不能替换字符串常量的内容的，那么如何把参数插入到字符串中？

    使用#

    作用：把一个宏参数变成对应的字符串。（比如：N是一个宏参数，我们使用#N，然后传过去a，那么a就会自动变成字符串 "a"）

    举例：

    1. #include
    2. #define PRINT(N) printf("the value of " #N " is %d\n", N)
    3.  
    4. int main()
    5. {
    6. 	int a = 10;
    7. 	PRINT(a); // printf("the value of a is %d\n", a);
    8.  
    9. 	int b = 20;
    10. 	PRINT(b); // printf("the value of b is %d\n", b);
    11.  
    12. 	return 0;
    13. }

    这里的：

    PRINT(a);

    将会被替换成： (提示：#N被替换成了 "a"，N被替换成了 a)

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

    运行结果：

    和上面用两个printf打印出来的结果一模一样。

    c7c58b71b68343af86fbf9d0a355ddb3.png

    额外补充：

    C语言规定，打印字符串时可以将一个字符串分成几个子串写入。

    举例：

    1. int main()
    2. {
    3. 	printf("san lian\n");
    4.  
    5. 	printf("san"   " "   "lian\n");
    6.  
    7. 	return 0;
    8. }

    运行结果：

    e0782a816cbe431c8fde1c0f5a52cbc5.png

    如果我们想要打印不同类型的变量，可以像下面这样：

    1. #include
    2. #define PRINT(N, format) printf("the value of " #N " is " #format "\n", N)
    3.  
    4. int main()
    5. {
    6. 	int a = 20;
    7. 	PRINT(a, %d); // printf("the value of a is %d\n", a);
    8.  
    9. 	double pai = 3.1415926;
    10. 	PRINT(pai, %lf); // printf("the value of pai is %lf\n", pai);
    11.  
    12. 	return 0;
    13. }

    运行结果：

    36979afd0fec448583fdd2f8650238c5.png

    ## 的作用：

    •  ##可以把位于它两边的符号合成一个符号。
    • 它允许宏定义从分离的文本片段创建标识符。

    举例：

    1. #include
    2. #define CAT(name1, num) name1##num
    3.  
    4. int main()
    5. {
    6. 	int sanlian333 = 666;
    7.  
    8. 	printf("%d\n", CAT(sanlian, 333));
    9.  
    10. 	return 0;
    11. }

    这里的：

    printf("%d\n", CAT(sanlian, 333));

    将会被替换成:

    printf("%d\n", sanlian333);

    运行结果：

    a61731670fa14d47b4d37b5926eff920.png

     注意：像上面这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

    5 带副作用的宏参数

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

    例如：

    1. int x = 1;
    2. int a = x+1; // 不带副作用（x的值没有改变）
    3. int b = ++x; // 带有副作用（x的值被改变）

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

    1. #include
    2. #define MAX(x, y) ((x) > (y) ? (x) : (y))
    3.  
    4. int main()
    5. {
    6. 	int a = 5;
    7. 	int b = 8;
    8. 	int c = MAX(a++, b++); // 被替换成 int c = MAX((a++) > (b++) ? (a++) : (b++));
    9.  
    10. 	// 你能不运行，说出下面的结果吗？
    11. 	printf("%d\n", a);
    12. 	printf("%d\n", b);
    13. 	printf("%d\n", c);
    14.  
    15. 	return 0;
    16. }

    运行结果：

    最后的结果是不是意料之外，却又在情理之中。（其实稍微细心点还是很容易看出答案的，但是稍不留神就有可能出错哦）

    cf2af496494642899ca1470d3636242f.png

     提示：所以为了避免出现不可预测的后果，在写宏的时候，参数部分尽量不要随便写这种带副作用的参数。

    总结

    还是那句话，虽然本文章读完不能让大家代码写得飞起，但是预处理这个过程是十分重要的，其中的很多指令也是经常被考到，只有了解了这个，你学编程才会更加的容易。当然我在这里只为大家讲了所有预处理指令里面十分重要的一些指令，如果大家还想深入的了解更多预处理指令，推荐大家可以去看看《C语言深度解剖》这本书。如果大家有什么解决不了的问题，欢迎大家评论区留言或者私信告诉我。如果感觉对自己有用的话，可以点个赞或关注鼓励一下博主，我会越做越好的，感谢各位的支持。

     

  • 相关阅读:
    利用向导创建MFC
    Java项目：SSM电影售票管理系统
    Splunk Enterprise 9.0.0 (macOS, Linux, Windows) -- 机器数据管理和分析
    Simulink 最基础教程（三）常用模块
    SpringCloud Alibaba 详解
    利用XXXXXXXXMIND管理。
    STC89C51基础及项目第13天：小车go、软件调速
    /var/lib/docker/aufs/mnt/ 空间占用高问题解决\查看磁盘空间
    java计算机毕业设计物流信息管理系统录像演示源码+系统+数据库+lw文档+mybatis+运行部署
    如何为微服务选择正确的消息队列
  • 原文地址：https://blog.csdn.net/qq_64042727/article/details/127283843