学C/C++想提升功底 可以花点时间看看这篇博客---C语言程序环境和预处理

本篇博客介绍了C语言程序环境和预处理.主要包含程序的翻译和运行环境和 各种预处理操作:预定义符号.各种#define 用法 undef的使用条件编译的使用 头文件包含指令

一.程序的翻译环境和执行环境

在ANSI C的任何一种实现中，存在两个不同的环境。
第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码

1.翻译环境

组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。
每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。
链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中

当有多个C源文件时,编译器编译时会将每个源文件都编译成目标文件,最后通过链接器将其合并形成一个可执行程序.

2.运行环境

程序执行的过程：

1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序 的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
2. 程序的执行便开始。接着便调用main函数。
3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回 地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程 一直保留他们的值。
4. 终止程序。正常终止main函数；也有可能是意外终止。

想要更深入了解翻译和运行环境推荐去看这本书-> <<程序员的自我修养>>

二.预处理详解

预处理是指在程序开始编译前编译器对所写的程序进行预先处理,主要涉及一些预处理符号 以#开头的预处理指令

1.预定义符号

在C语言里有内置的预定义符号:

FILE //进行编译的源文件
LINE //文件当前的行号
DATE //文件被编译的日期
TIME //文件被编译的时间
STDC //如果编译器遵循ANSI C，其值为1，否则未定义

内置的这些符号在写代码时可以加上,可用于编译运行时输出需要知道的对应信息类似于日志信息

========================================================
下面看看使用方法↓

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
	printf("=================\n");
	printf("%s\n", __FILE__);   // 输出进行编译的源文件
	printf("%d\n", __LINE__);  //输出当前的语句所在行数
	printf("%s\n", __DATE__); //输出当前编译运行时日期
	printf("%s\n", __TIME__); //输出当前编译运行时时间
	printf("=================\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

通过输出函数对应的输出格式输出这些预定义符号表示的含义…

2.#define的用法

#define是C语言中的一个预处理指令,主要用于在编译前阶段对数据进行一些相应操作

①. #define 定义标识符

语法:
#define name(标识符名字) stuff(标识符要表示的具体内容)

举个例子:

上图示例 将 定义了标识符NUM 表达的内容为数字常量6
此时NUM就相当与一个数字常量6赋值给了变量num,最后通过printf函数输出…

========================================================
#define定义的标识符不仅仅只能表达一个数字常量 甚至还可以这样写↓

此时NUM表达 的含义是 6); 意味着在printf 函数输出NUM时后面的)和;都可以不用写!!!

注意:既然#define 定义的标识符可以表达任意替换的内容,
为了执行int num =NUM;这种操作时更方便
可不可以在NUM定义的时候表示为数字;呢?

比如:
#define MAX 1000;
#define MAX 1000

虽然这样做可以,但是只是方便了一下,但会留下很大的隐患.
在常量数字后面加分号是不建议的!因为在实际场景中可能不仅仅需要赋值,也有可能直接输出MAX 此时后面多了一个;反而无法去除,所以不要省着一下方便把分号也加上去…毕竟每条语句都手动加上分号代码更规范美观

②.#define定义宏

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

下面是使用格式:

#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。
注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

下面看使用示例:

上面代码通过#define宏定义了 ADD(a,b) a+b
表达的含义是当在下面代码里使用ADD(参数1,参数2) 时 会将两个参数替换掉a和b
此时ADD(a,b)表示的就是 参数1+参数2 的意思 而代码中参数为常量数字1和2最后结果为1+2输出为6

========================================================
现在看看下面代码输出结果是什么↓

#define _CRT_SECURE_NO_WARNINGS
#include
//#define NUM 6
#define MUL(a,b) a*b

int main()
{
	//printf("=================\n");
	printf("%s\n", __FILE__);   // 输出进行编译的源文件
	//printf("%d\n", __LINE__);  //输出当前的语句所在行数
	//printf("%s\n", __DATE__); //输出当前编译运行时日期
	//printf("%s\n", __TIME__); //输出当前编译运行时时间
	//printf("=================\n");

	

	/*printf("%d\n", NUM);*/

	printf("%d\n", MUL(2+2,3)); //输出结果是什么?

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

正常来看都会觉得先执行2+2为4 再替换过去 最后为43 结果为12
但是↓

最后得到的结果却是8, 因为在#define 定义的宏 是会直接先执行替换的,即将2+2 和3 先替换 最后 表达的含义是2+23 而乘法优先执行 此时结果为8

如果要达到输出12的效果此时ADD(a,b)应该定义为(a)*b 表达的含义才会为(2+2)*3

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

③.#define替换规则

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

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先 被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上 述处理过程。 注意：
4. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
5. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#define定义的标识符 是可以嵌套使用的

#define 定义的标识符 不能定义自身即类似于递归这种用法–↓

④. #define宏定义- -实现字符串连接特点

先看看下面代码会输出什么结果?↓

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
	char* p = "hello ""world\n";
	printf("hello"" world\n");
	printf("%s", p);
	return 0;
}
1
2
3
4
5
6
7
8
9

可以看到输出结果都为 hello world 此时两个由双引号引起的字符串都被输出了 我们发现字符串它有自动连接的特点

那么是不是还可以用#define 实现 宏定义 这样写代码↓

#define _CRT_SECURE_NO_WARNINGS
#define PRINTF(format,value) printf("The value is " format "\n",value)
#include
int main()
{
	
	PRINTF("%d ", 6); //输出结果是什么
	return 0;
}
1
2
3
4
5
6
7
8
9

可以看到最后结果输出了 The value is 6
这是因为#define 宏定义 PRINT(format,value) 为 printf(“The value is " format “\n”,value)
使用宏定义 此时”%d"替换了 format 6替换了 value
最后相当于是printf("The value is " “%d” “\n”,6) 这样的语句
而通过上面的字符串连接特点 相当于printf(“The value is %d \n”,6) 这个语句 最后发现 结果输出结果正是 The value is 6

⑤. #define实现宏定义时#和##的使用

在使用#define宏定义时 使 可以借助# 将一个宏参数变成对应的字符串

来看看下面代码输出结果是什么 ↓

#define _CRT_SECURE_NO_WARNINGS
//#define PRINTF(format,value) printf("The value is " format "\n",value)
#define PRINTF(FORMAT, VALUE) printf("the value of " #VALUE " is "FORMAT "\n", VALUE)
#include
int main()
{
	/*char* p = "hello ""world\n";
	printf("hello"" world\n");
	printf("%s", p);*/
	PRINTF("%d ", 1+2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

首先进行宏参数替换 结果为 printf(“the value of " #1+2 " is “”%d” “\n”, 1+2)
根据#号的使用将1+2这个宏参数变成字符串"1+2"
此时结果为 printf(“the value of " “1+2” " is “”%d” “\n”, 1+2)
经过字符串连接后结果为"the value of 1+2 is %d \n",1+2)
最后输出结果为the value of 1+2 is 3

发现#配合字符串连接这种方法可以使宏参数1+2转换为直接输出出来而不会被计算为3

##的作用:

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

#define _CRT_SECURE_NO_WARNINGS

#define ADD_TO_SUM(num, value) sum##num += value;
#include
int main()
{
	
	int sum6 = 3;
	ADD_TO_SUM(6, 3);
	printf("%d ", sum6);//输出结果为什么
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

先进行宏参数替换 结果为sum##6+=3
根据##的用法将两边符号合成一个符号结果为 sum6+=3
而此时这个式子就是一个赋值表达式 sum6=sum6+3 而sum6里的值为3 经过赋值后结果为6

注意:当##连接的左右两边得到的符号不是合法标识符时,此时结果是未定义

⑥.带副作用的宏参数

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

x+1;//不带副作用
x++;//带有副作用
1
2

下面这串代码 输出结果是什么?

#define _CRT_SECURE_NO_WARNINGS
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
#include
int main()
{

	
	int x = 5;
	int y = 8;
	int z = MAX(x++, y++);
	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

先进行宏参数替换结果为((x++)>(y++)?(x++):(y++))
先算x++ >y++ 此时结果为 5>8 x里的值为6 ,y里的值为9
5>8表达式为假 运算y++ 结果为 9 y里的值为10
将9赋值给z z里的值为9
总结得出 x的值为6 y里的值为10 z里的值为9

一道简单的三目运算符,因为使用了带副作用的宏参数即运算后给对应变量的值带来永久性改变
从而使得计算起来变得复杂

总结:在使用宏定义时 尽量不要使用 x++ 等会影响原来参数的值的宏参数

⑦ 宏和函数的比较

经过上面使用的一些宏定义的例子,我们发现宏定义通过宏参数替换也能实现一些函数能实现的效果,并且比函数实现更快捷
比如:

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

找俩个数最大值 此时用宏定义 比函数更方便,以下有倆个原因↓

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。 所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。 所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以 用于>来比较的类型。
   因为宏不考虑数据的类型

当然宏也是有缺点的

1 . 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
2.宏是没法调试的
3.宏由于类型无关，也就不够严谨。
4 宏可能会带来运算符优先级的问题，导致程容易出现错。

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

#define MALLOC(num, type) (type *)malloc(num * sizeof(type))
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));  //而函数做不到这样
1
2
3
4
5

宏和函数的对比

⑧ 命名约定

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

宏定义的宏名 全部用大写
函数名全部用小写

3.undef的使用

#undef的作用就是移除一个对应的#define宏定义

根据上图可以看到 #define定义了标识符NUM表示为常量3 第一次的NUM可以使用 ,但在后面使用了#undef NUM 此时 NUM被取消了#define定义标识符 表示3 此时NUM仅仅是一个标识符

#undef的作用可以是在当这个NUM标识符不想表示常量3 想作为变量时 NUM在编译前都一直被替换为了常量3 此时NUM不能被定义为变量 而#undef 取消了NUM定义的标识符 此时NUM就可以作为被定义为变量

4.条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件
编译指令。

比如当我们在程序运行过程中需要调试或测试某项功能是否正常,在测试完后不想将其删除,可以将这块语句注释起来,也可以用条件编译使这块语句不被执行

1.单分支条件编译
#if 常量表达式 
//...   常量表达式为真时要执行的语句
#endif  //条件编译结尾
1
2
3
4

下面是示例代码

2.多个分支的条件编译
#if 常量表达式1
//...     //表达式1为真 则只执行该区域代码
#elif 常量表达式2
//...     // 当表达式1为假表达式2为真则执行该区域代码
#else
//...    //当上面表达式都为假则执行当前区域代码
#endif
1
2
3
4
5
6
7
8

下面是示例代码

3.判断是否被定义
#if defined(symbol) 
...  // 如果定义了symbol则运行当前区域代码 未定义则不运行
#endif
//上面的也可以简写为下面代码
#ifdef symbol      
...
#endif

#if !defined(symbol)
...    //如果没定义symbol 则运行该区域代码块  定义了则不运行  也可以写成下面的形式
#ifndef symbol
...
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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
1
2
3
4
5
6
7
8
9
10
11
12
13

下面是示例代码

5.#include文件包含指令

在使用C语言第一条指令都是#include 它的作用也就是文件包含指令,表示将对应的文件在当前程序进行一次展开,即将对应的头文件拷贝一份到当前程序

①.头文件被包含的方式

1.本地文件包含

#include "filename.h"
1

当前指令 头文件名用""括起来 表示编译器在编译前会在当前文件目录下寻找filename.h头文件,如果找到了,则将其包含在当前程序内,如果没有找到,则会在库文件所在的目录下寻找filename.h头文件
如果找不到就提示编译错误。

#include
1

当前指令 头文件名用<>括起来 表示编译器在编译前会在库文件所在的目录下寻找stdio.h 头文件 找到后将其包含到程序中 如果找不到就提示编译错误。

建议查找库函数头文件用<>而不是"" 虽然用""也可以找到对应的库函数头文件
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

②.如何避免头文件被重复包含

当我们编写代码中可能会出现类似于上面图片的情况,反复包含了stdio.h头文件 ,此时并不会编译报错
但是我们知道 包含一个头文件就是一次拷贝,此时头文件对应的内容被拷贝在了当前程序中,而你多次包含那就多次拷贝了,此时使得程序就有了过多不必要的重复的包含…

而如何解决这种问题呢,有两种方法
1.条件编译

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif
1
2
3
4

上面图片可以看到每次头文件包含都放在一个条件编译中只有第一次 条件编译表达式为真 包含了头文件 ,第一次条件编译定义了NUM 后面的三次 则表达式都为假 即不会再包含头文件

2.#pragma once预处理指令

此时在开头使用#pragma once 后 在下面多次包含了stdio.h头文件 也只会包含其中一个

当然还有一些预处理指令
#error message // 当运行到 此指令 显示结束编译并 message 错误信息
#pragma pack() 修改编译器默认对齐数
…

三.程序环境和预处理总结

本篇博客总结了C语言程序环境 和预处理的各种操作…
这些预处理操作绝大多数都是比较冷门不常见的,但是学习要有深度也要有广度,可以不用但得见过
多接触预处理指令 多了解编译前的一些数据操作也能提高对底层的一些了解