C中的预处理细节知识汇总.

1. 预处理宏

C中的预处理是一个编译过程, 主要提前处理的是一些非语法问题. 比如说去掉注释啦, 比如说展开头文件, 再比如说处理宏了…

下面我们着重去介绍C中宏问题. C中的宏挺多的, 类型也挺多, 下面依次进行介绍.

1.1 数值宏常量

我们建议: 把字面量定义为宏常量.

#define M 1000

上面就是一个数值宏常量的举例.

问: 为啥这些字面量设置为宏呢?
答: 在代码中可能会出现多次, 这样做方便进行维护.

1.2 字符串宏常量

字符串宏常量也是经常使用的一个东西.
我们用下面代码进行测试:

#define PATH1 "C:\\Users\\szg\\Desktop\\文件夹1\\文件1-1\\1-课件\\1.C语\
言课件\\C语言深度剖析"
int main()
{
	const char *path = PATH1;
	printf("%s\n", path);
	system("pause");
	return 0;
}

因此, 我们得出了以下几点建议:
1. 宏定义代表字符串的时候，一定要带上双引号
2. 如果字符串比较长, 可以用\续行
3. 如果涉及到""问题, “\\”<==>‘\’

1.3 用宏定义充当注释符号???

可能有人比较了解C的话可能知道, C中的宏是预处理期间替换符号的, 所以有人就想了, 可以用宏来替换"//"来达到重命名注释符号的一个效果吗?
答: 先说结论, 不能.

我们先来复习一下C的编译过程:

//预处理-E ：头文件展开，去注释，宏替换
//编译-S ： 将干净的C语言，编译成为汇编语言
//汇编-c ：将汇编翻译成为目标二进制文件
//链接 ：将目标二进制文件与相关库链接，形成可执行程序

实际上要回答是否能用宏去替换注释符号的问题呢, 就要看预处理期间是先去注释还是先去进行宏替换了.

我们用下面代码测试一下:

#define BSC //
int main()
{
    BSC printf("hello world\n");
    return 0;
}

显然是不行的. 为啥呢? 因为宏在替换之前就去掉注释了, 也就是替换了个寂寞…

具体情况如下:
我们对比一下test.i 与 test.c, 问为啥没有看见替换内容???

int main()
{
    printf("hello world\n");
    return 0;
}
//倘若，先执行宏替换，那么先得到的代码应该是
int main()
{
    //将BSC替换成为‘//’
    // printf("hello world\n");
    return 0;
}
//再执行去注释，那么代码最终的样子，应该是
int main()
{
    return 0; //printf被注释掉
}

结论：预处理期间：先执行去注释，在进行宏替换

那么有人可能就好奇了, CPP风格的注释可以进行宏替换吗?
答: 会编不过, 编译阶段语法报错.

#include <stdio.h>
#define BSC //
#define BMC /*
#define EMC */ //注意：EMC已经被是先被注释掉的哦，BMC成为空
int main()
{
    BSC printf("hello world\n");
    BMC printf("hello bit\n"); EMC
    return 0;
}

为啥C设计者会把预处理过程设计为先去注释再进行宏替换呢???
答: 我猜测是为了提高效率的考量. 假如说注释中有很多根宏一样的符号, 如果先宏替换, 那么注释中的内容也会被替换掉, 肯定计算机会"多干活"的. 因此, C的编译效率也就变低了, 但是如果先去注释, 再宏替换呢? 我想直接去掉注释内容对计算机来说更加友好一些~ 毕竟注释是给人看的, 而不是给计算机看的.

1.4 拓展: 问: 先有语言还是先有编译器问题???

先有语言规则, 然后再有编译器.
这个具体我记得很久之前就写过相关的博客, 可以见: LINK

1.5 拓展: 问: C语言直接翻译为二进制吗?

答: 实际上, C不是直接翻译为二进制的, 当然可以做到, 只是把C先翻译为汇编在翻译为二进制更加快速实现一些. 我说的这个快速实现指的是从历史角度把C翻译为二进制这个实现出来更快一些.

1.6 用 define 宏定义表达式

这个宏定义表达式的问题呢, 我们收集了几个常见的小问题, 列举了一下:
问题1: 下述宏定义中的"SUM", “SQR"是宏吗?
#define SQR(x) ((x)*(x))
#define SUM(x) ((x)+(x))
答: 当然是的!
问题2: #define empty 这样定义ok吗?
答: 是没问题的, 只不过会把程序中的empty处替换为空而已~ 也就是啥都不替换.
问题3: 下述代码打印结果是啥???
#define SUM(x) ((x)+(x))
printf(“SUM(x)\n”);
答: 仍然是"SUM(x)”, 因为对于字符串中的内容, 宏不会进行替换.
问题4: “#define M 100"是宏定义吗?
答: 不是, 只是一个字符串字面量而已, 在C中, 啥东西扔到”"里面都会变成字符串, 而不做语法解释.
问题5: 下面宏定义有啥问题吗? 如何进行修正???
#define INTI_RECT_VALUE(a, b)
a = 0;
b = 0;

小技巧: 用do-while-(0)结构进行处理.

1.7 宏定义中的空格

下面只是一个写宏定义和使用宏的时候两个小细节, 了解一下即可.
第一个, #define写的时候可以写成: # define, 也就是#和define可以隔一个(多个)空格.

#include <stdio.h>
# define INC(a) ((a)++)

显然, 上面代码是正确的.

第二个, 在使用宏的时候名字和小括号也可以隔一个(多个)空格.

#include <stdio.h>
#define INC(a) ((a)++) //定义不能带空格
int main()
{
    int i = 0;
    INC (i); //使用可以带空格，但是严重不推荐(不要处处显得自己不一样哦)
    printf("%d\n", i);
}

1.8 #undef

上面讨论的是宏定义的问题, 下面我们讨论的是取消宏的问题.
先探讨2个问题：

1. 宏只能在main上面定义吗？
2. 在一个源文件内，宏的有效范围是什么?

问题1: 宏只能在main上面定义吗？
答: 在哪定义都行, 即使是在函数内, 甚至在最下面一行都ok~

#include <stdio.h>
#define M 10
int main()
{
    #define N 100
    printf("%d, %d\n", M, N);
    return 0;
}

问题2: 在一个源文件内，宏的有效范围是什么?
答:
在没有#undef情况下, 从定义开始处, 到文件结尾(EOF处)
在#undef情况下, 会到#undef那一行.

问题3: 下面代码结果是多少? 还是编译报错???

#include <stdio.h>
int main()
{
    #define X 3
    #define Y X*2
    #undef X
    #define X 2
    int z = Y;
    printf("%d\n", z);
    return 0;
}

答: 是4, 因为

2. 条件编译

我们先来看看有哪些常见的条件编译形式??? 只有下面两种:
首先第一种是:


仅仅是摆两段代码是不行的, 所以我们接下来去解释一下代码的含义是啥.

首先, 我们有必要去弄清楚宏定义和宏为真的问题.

2.1 宏定义? 宏为真?

#ifdef 标识符, 这个代码呢, 是用来判断宏标识符是否被定义, 如果被定义的话下面代码会保留, 反之会在预处理阶段删除.

#define A 1
#define A 0
#define A 

上边的A都属于定义!
#if 表达式
上面这个代码判断的是表达式是否为真, 如果为真就保留相关代码

#define A 1
#define A 0
#define A 

上边的只有第一个是宏为真!

2.2 条件编译的意义?

根据不同平台/条件, 动态自动的裁剪代码, 只需要维护一份代码即可.

比如说, 有个软件代码可能比较庞大, 几百万行代码, 然后呢适配Windwos, Linux以及MacOS多种平台, 这样的话在编译安装的时候, 往往会去检测当前的环境, 自动去进行代码裁剪, 代码裁剪的好处就是二进制后代码体积变小, 使得代码占用内存也随之变少, 也就提高了代码的运行效率(减少代码膨胀问题). 并且对于开发者来说也方便进行维护.

3. 文件包含 #pragma once

几乎所有的比较严谨的头文件最上面都会有这么一句代码, 为啥呢??? (可能也有的是#ifndef…)

这需要我们首先明白#include XXX到底做了什么? --> 把头文件展开.
我们下面在Linux环境下进行测试:

也就是说上面那个代码展开之后展开了接近八百行…

所以说呢, #pragma onece的作用就是防止头文件被重复包含, 从而导致代码体积膨胀的问题.

严格来说, 头文件重复包含不算是错误, 不过会引起多余的拷贝, 从而导致效率降低, 不过可能会引起一些未知错误.

4. #error

我们用下面代码测试一下:

#include <stdio.h>
//#define __cplusplus
int main()
{
    //#error 你好啊
#ifndef __cplusplus
#error 错误
#endif
    system("pause");
    return 0;
}

上面这个代码是编译不过的. 报错输出信息如下:

结论:核心作用是可以进行自定义编译报错.

其中, Linux下的测试如下:

个人感觉没啥用… 我也从来没用到过…

5. #line

首先, 你得知道我们C语言有俩宏, 可以获取调用宏的行号和文件名.

#include <stdio.h>
int main()
{
printf("%s, %d\n", __FILE__, __LINE__); //C预定义符号，代表当前文件名和代码行号
return 0;
}

之后呢, 我们这个#line可以修改这两个宏.
比如:

我感觉这个也没啥用…

6. #pragma

6.1 #pragma message()

作用: 可以用来进行对代码中特定的符号(比如其他宏定义)进行是否存在进行编译时消息提醒.

实际上与#error差不多, 区别在于#pragma message()会让程序编译成功, 只是提示级别, 而#error直接不允许编译.

#pragma还有一个比较常用的是, #pragma warning(disable:4996)

6.2 #pragma warning(disable:4996)

VS 2022下, 不写这个#pragma warning(disable:4996)就会报错, 这个实际上就是忽略编译器警告的含义.

当然, 另一种方法是: This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

6.3 #pragma pack()

这个就是设定对齐数的, 用来算那个结构体大小的时候用的, 不多说. VS下默认对其数是8.

6.4 #pragma once

这个是防止头文件多次重复包含的, 等价于:

#ifndef XXX
#def XXX
//...
#endif

这个前面说过, 不再多说.

7. # 运算符

7.1 字符串具有连续性特点.

#include<stdio.h>
#include <windows.h>
int main()
{
	printf("hello"" world""\n");
	const char* msg = "hello""msg""\n";
	printf(msg);

	return 0;
}

上面这个代码是正确的. 你看:

7.2 #: 作用是把任何符号字符串化.

实际上, 代码没被编译前, 也就是在预处理阶段, 都被编译器看作是一些符号而已. 然后这些符号可以用#来在编译器编译根据语法编译这些符号前去把这个符号字符串化.

比如下面这个例子:

#include<stdio.h>
#include <windows.h>
#pragma warning(disable:4996)
#define STR(s) #s
int main()
{
	char buf[64];
	strcpy(buf, STR(buf));
	printf("%s\n", buf);

	return 0;
}

8. ## 运算符

作用: 将##相连的两个符号，连接成为一个符号

请看下面例子:

#define XNAME(n) x##n
int main()
{
	int XNAME(9) = 10;
	return 0;
}

咱看看预处理之后是个啥???

再比如说:

#include<stdio.h>
#include <windows.h>
#pragma warning(disable:4996)
#define CONT(x,n) (x##e##n)
int main()
{
	printf("%f\n", CONT(1.1,2)); //计算浮点数科学计数法，相当于1.1 * (10^2)
	system("pause");
	return 0;
}

似乎也没啥用, 基本上用不到, 不过#和##在一些C项目中可能会有花活.

9. 总结

本节主题是预处理.
我们先谈了一下预处理中重要的宏, 包括数值常量宏, 字符串常量宏, 宏表达式等等.
之后我们又说了一下条件编译.
之后又说了一下预处理中的文件包含, #error宏和#line宏.
最后还提及了在预处理阶段运算俩运算符#和##.

整体很easy.

---

EOF.