一、程序的翻译环境与执行环境

在ANSI C的任何一种实现中，存在两个不同的环境。

  • 第一种是翻译环境，在这个环境中源代码被转换为可执行的机械指令。
  • 第二种是执行环境，它用于实际执行代码。

程序环境和预处理_预处理指令

二、详解编译+链接

1、翻译环境

翻译环境里有编译器和链接器两个工具，在VS的环境下，编译器叫cl.exe、链接器叫link.exe。 

在一个工程中，可能有多个.c、.h文件，每一个源文件都会单独经过编译器编译，最终每个源文件都会生成对应的目标文件，然后多个目标文件经过链接器把链接库一起链接最后生成可执行程序。

程序环境和预处理_#define_02

在编译的过程中，又分为三个步骤，预编译（预处理），编译，汇编。

程序环境和预处理_#endif_03

2、预编译

预编译有会执行什么功能呢？

预编译阶段多是文本操作，与预处理的指令相关（例如#define，#include等等），主要包含以下功能：

①头文件的包含。

②注释的删除。

③#define定义符号的替换。

我们在gcc的环境下来验证：

gcc环境下源文件在预处理结束后会生成.i文件。

程序环境和预处理_#endif_04

3、编译

编译阶段把C语言代码翻译成汇编代码，主要执行以下功能：

①语法分析。

②词法分析。

③语义分析。

④符号汇总。

编译完后，会生成一个.s文件

程序环境和预处理_翻译环境_05

如图，这就是.s文件，都是汇编语言。

4、汇编

汇编阶段会把汇编代码转化成目标文件

注意，VS环境下，目标文件后缀是.obj

gcc环境下，目标文件后缀是.o

汇编执行的功能是：

①把汇编代码转换成二进制指令。

②形成符号表。

程序环境和预处理_预处理指令_06

5、链接

链接阶段会产生后缀为.exe的可执行程序

链接阶段要执行的功能是：

①合并段表。

②符号标的合并和重定位。

6、翻译环境总结

最后，我们进行以下总结：

程序环境和预处理_#endif_07

7、符号表

在编译阶段，编译器实现了符号汇总。在汇编阶段，编译器实现了形成符号表。在链接阶段，链接器实现了符号标的合并与重定位。

接下来我们就来探究一下这三个功能是什么。

假设我们写了两个源文件

程序环境和预处理_#define_08

①符号汇总

在编译解阶段会把全局的符号汇总起来

程序环境和预处理_预处理指令_09

②形成符号表

在汇编阶段会根据全局符号的地址形成表格。

因为Add函数在test.c中只声明了，没有定义，我们在编译阶段是每个源文件单独编译，所以在test.c中并不知道它的实际地址，所以它的地址是无效地址，就假设是0x000

程序环境和预处理_#define_10

③符号表的合并与重定位

在链接阶段进行符号标的合并，在合并中发现了相同的两个Add，一个地址为0x000，一个地址为0x120，因为0x000是一个无效地址，此时重定位，选择地址为0x120。

程序环境和预处理_#endif_11

④符号表的作用

举个例子：

程序环境和预处理_翻译环境_12

此时运行该程序，就会报错，

程序环境和预处理_翻译环境_13

所以，符号表的作用是为链接期间，跨源文件的代码协作进行铺垫。

三、执行环境

程序执行的过程：

1、程序必须载入到内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。

2、程序的执行开始，接着便调用main函数。

3、开始执行程序代码。这个时候程序将使用一个运行堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程中一直保留他们的值。

4、终止程序。正常终止main函数，也有可能是意外终止。

四、预处理指令详解

1、预定义符号

在预处理阶段就定义好的符号，这些符号可以直接使用

__FILE__//进行编译的源文件
	__LINE__//文件当前的行号
	__DATE__//文件被编译的日期
	__TIME__//文件被编译的时间
	__STDC__//如果编译器严格遵循ANSI C，其值为1，否则未定义

实例演示如下：

#include<stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (i = 0;i < 10;i++)
	{
		printf("%d-----%s, ", arr[i], __FILE__);//打印当前编译的源文件
		printf("%s, ", __DATE__);//打印编译日期
		printf("%s, ", __TIME__);//打印编译时间
		printf("line=%d\n", __LINE__);//打印编译行号
	}
	return 0;
}

运行结果如下：

程序环境和预处理_#define_14

在VS的环境下使用__STDC__

程序环境和预处理_翻译环境_15

__STDC__未定义，所以VS编译器没有严格遵守C语言标准。

在gcc的环境下使用__STDC__

程序环境和预处理_翻译环境_16

程序环境和预处理_预处理指令_17

__STDC__的值为1，所以gcc编译器严格遵守从语言标准。

2、#define

2.1#define定义标识符

语法

#define name

举个例子

#define MAX 1000
#define C char

#define的符号在预编译阶段会直接进行替换

程序环境和预处理_#endif_18

如上图，在预编译后生成的bbc.i中，MAX被替换成了1000，C被替换成了char

注意，#define定义的符号后面要不要加分号

#define MAX 1000//不加分号
#define MAX 1000;//加分号

看下面这段代码

程序环境和预处理_预处理指令_19

在与编译后，MAX被替换成了1000；，注意，连分号都替换了了，所以最后这段代码就出错了。

所以，#define定义的符号后面不要加分号

2.2#define定义宏

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

下面是宏的声明方式

#define name(parament-list) stuff

其中的parament是参数列表，可能是一个或者多个，参数间用逗号隔开，这些参数可能出现在stuff中。

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

如

#define (x) x*x

这个宏接受一个参数x。

如果在程序中使用

(5);

在预处理阶段就会替换，就会用下面这个式子替换上面的式子

5*5；

看下面这段代码：

#define SQUARE(x) x*x//实现求一个数的平方
int main()
{
	int c = SQUARE(5 + 1);//我们希望求(5+1)的平方
	printf("%d\n", c);
	return 0;
}

我们希望c的结果是36，但是真正的结果是11。

程序环境和预处理_翻译环境_20

这是为什么呢，因为宏参数的替换是直接的替换，不会进行计算。

也就是说把

int c = SQUARE(5 + 1);

替换成了

int c = 5+1*5+1;

所以最后的结果是11。

为了避免这种错误，我们要毫不吝啬地多加括号，

例如

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

注意，我们给整体也加上了括号，下面来演示一下如果不给整体加括号会怎么样。

#define ADD(x,y) (x)+(y)//实现两数相加
int main()
{
	int c = 10 * ADD(2, 3);//我们希望求的是10*(2+3);
	printf("%d\n", c);
	return 0;
}

最终的结果是23，而不是50。

程序环境和预处理_#define_21

下面这段代码是用宏实现求两个数的最大值

#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
	int c = MAX(7, 1 + 9);
	printf("%d\n", c);
	return 0;
}

运行结果：

程序环境和预处理_预处理指令_22

2.3#define的替换规则

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

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

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

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

举个例子，下面这段代码

#define MAX(x,y) ((x)>(y)?(x):(y))
#define X 12
int main()
{
	int c = MAX(7, X);
	printf("%d\n", c);
	return 0;
}

首先检测到参数中的X时#define定义的符号，就把

int c = MAX(7, X);

替换成

int c = MAX(7, 12);

然后检测发现还有#define定义的符号，就把

int c = MAX(7, 12);

替换成

int c = ((7) > (12) ? (7) : (12));

2.4#符号

看下面这段代码

int main()
{
	char* p = "Hello ""bit\n";
	printf("Hello ""bit\n");
	printf("%s", p);
	return 0;
}

这段代码最后打印的两个结果都是Hello bit 吗？

答案是是的

程序环境和预处理_翻译环境_23

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


再看下面这段代码：

#define PRINTF(nums,x) printf("nums=x",num)//nums是变量名，x是变量类型。
int main()
{
	int a = 10;
	PRINTF(a,"%d");//我们希望得到a=10
	return 0;
}

然而这段代码并不能实现我们先要的结果，因为“nums=x”是一个字符串，而非符号，没办法实现替换。

那我们换思路，把nums和x拿出字符串

#define PRINTF(num,x) printf(nums"="x,num);

我们希望第一个nums被替换成字符串"a",x被替换成“%d”，第二个nums被替换成a（变量a，其值为10）。

这个时候，我们就需要#。

#的功能是，把一个宏参数变成对应的字符串。

下面是利用#，修改的代码

#define PRINTF(nums,x) printf(#nums"="#x,nums)//nums是变量名，x是变量类型。
int main()
{
	int a = 10;
	PRINTF(a, %d);//我们希望得到a=10
	return 0;
}

最终上面这段代码在预编译阶段被替换为下面这段代码

程序环境和预处理_#define_24

最终运行结果是

程序环境和预处理_#endif_25

2.5##符号

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

它允许宏定义可以从分离的文本片段创建标识符

实例演示如下

#include<stdio.h>
#define Class110 2023
#define CAT(x,y) x##y
int main()
{
    printf("%d",CAT(Class,110));
    return 0;
}

x被替换成Class，y被替换成110，然后##把Class和110合成一个符号，最终得到Class110，所以最后打印的结果是2023。

程序环境和预处理_#define_26

##合成产生的符号必须是一个合法的标识符，否则其结果是未定义的。

如果是Class##110，最后合成的符号是Class110，是我们用#define定义的符号。如果是Class##111，最后合成的符号应该是Class111，这个符号是非法的标识符，所以最后的结果是未定义的。

2.6带有副作用的宏参数

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

举个例子

#define MAX(x,y) ((x)>(y)?(x):(y))//这是一个求较大值的宏
int main()
{
	int a = 3;
	int b = 5;
	int c = MAX(a++, b++);//这里的a++与b++就是带有副作用的宏
	printf("a=%d\n", a);
	printf("b=%d\n", b);
	printf("c=%d\n", c);
	return 0;
}

既然MAX是求较大值的宏，而且a++与b++都是先使用再++。所以按理来说c的值应该是5，a的值应该是4，b的值应该是6。然后最后的运行结果是

程序环境和预处理_#define_27

为什么呢，因为在预编译阶段，把

int c = MAX(a++, b++);

替换成

int c = ((a++) > (b++) ? (a++) : (b++));

所以b先++一次，变成6，赋值给c，然后b在++一次，变成7。所以最后得到的结果并不像我们预想的那样。

如果我们使用函数来求较大值

int Max(int x, int y)
{
	return x > y ? x : y;
}
int main()
{
	int a = 3;
	int b = 5;
	int c = Max(a++, b++);
	printf("a=%d\n", a);
	printf("b=%d\n", b);
	printf("c=%d\n", c);
	return 0;
}

运行结果：

程序环境和预处理_翻译环境_28

就不会出现像宏那样的副作用。

2.7宏和函数的对比

宏通常被应用于执行简单的运算。

比如说在两个数中找出较大的值

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

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

原因有二：

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

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

当然，和函数相比，宏也有劣势的地方：

①每次使用宏的时候，一分宏定义的代码插入程序中。除非宏比较短，否则可能大幅度增加程序的长度。

②宏是无法调试的。

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

④宏可能带来运算符优先级的问题，导致容易出错。


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

#define MALLOC(num ,type) (type*)malloc(num*sizeof(type))
int main()
{
	//使用
	MALLOC(10,int);
	//被替换成(int*)malloc(10*sizeof(int));
	return 0;
}

宏和函数对比表

属性

#define定义宏

函数

代码长度

每次使用时，宏代码都会被插入到程序中。出了非常小的宏之外，程序的长度都会大幅度增长。

函数只出现于一个地方。每次使用这个函数时，都调用那个地方的同一份代码。

执行速度


更快。

存在函数的调用和返回的额外开销，所以相对慢一些

操作符优先级

宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议在宏的书写时多加些括号。

函数参数只是在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。

带有副作用的参数

参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预测的结果。

函数参数只在传参的时候求值一次，更容易控制。

参数类型

宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用任何参数类型。

函数的参数是与类型相关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是相同的。

调试

宏是不方便调试的。

函数是可以逐语句调试的。

递归

宏是不能递归的。

函数是可以递归的。

2.8命名约定

一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区别二者。

所以我们平时都有一个习惯

把宏名全部大写

函数名不要全部大写

3、#undef

这条指令用于移除一个宏定义。

格式为

#undef

程序环境和预处理_#endif_29

当M被移除后，代码就无法正确执行。

4、条件编译

在编译一个程序的时候，我们可以用条件编译指令设置一个条件，满足这个条件时，让一些语句编译，当不满足条件是时，让这些语句不编译。也就是说我们能决定这些语句是否参与编译。

常见的条件编译指令：

第一条指令是：

#if    常量表达式
//......
#endif//用于结束条件编译指令
//常量表达式在预处理阶段求值

举个例子

#include<stdio.h>
#define A 1
#define B 0
int main()
{
    #if A
    printf("hehe");
    int a=0;
    #endif
    #if B
    printf("hello");
    int b=2;
    #endif
    return 0;
}

A为真，所以下面的语句参与编译，B为假，所以下面的语句不参与编译，下面是预编译后的代码

程序环境和预处理_翻译环境_30

#if 2==1//这样的常量表达式也是可以的，这个常量表达式为假

第二条指令是多个分支的条件编译：

if  常量表达式
//......
elif  常量表达式
//.......
elif 常量表达式
//......
endif

举个例子

#include<stdio.h>
#define A 0
#define B 1
int main()
{
    #if A
    printf("hehe");//代码1
    #elif B
    printf("hello");//代码2
    #else
    printf("good");//代码3
    #endif
    return 0;
}

其实上面讲的这两条条件编译指令和接下来要讲的条件编译指令的语法和if语句是十分相似的。

上面这段代码，其实就是如果A为真，编译代码1，否则编译代码2或3。如果B为真，编译代码2，否则编译代码3。所以上面这段代码只会编译代码2。

下面是预编译后的代码：

程序环境和预处理_预处理指令_31

第三条指令是判断是否被定义：

#ifdefine symbol
//......
#def !symbol
//......

举个例子

#include<stdio.h>
#define A 0
#define B 
int main()
{
    #ifdef A//有定义就编译
    printf("hehe");//语句1
    #endif
    #ifndef B//没有定义才编译
    printf("haha");//语句2
    #endif
    #ifdef C//有定义就编译
    printf("hello");//语句3
    #endif
    #ifndef D//没有定义才编译
    printf("byebye");//语句4
    #endif
    return 0;
}

只有A和B定义了，所以只有语句1和语句4参与编译。

下面是预编译后的代码：

程序环境和预处理_预处理指令_32

第四条指令是嵌套指令：

条件编译指令是允许嵌套使用的

#ifdef A
	#ifdef B
	//......
	#endif
	#ifdef C
	//......
	#endif
#endif
#if A
	#if B
	//......
	#elif C
	//......
	#else D
	//......
	#endif
#endif

看例子

#include<stdio.h>
#define A 1
#define B 0
#define C 0
#define D 1
int main()
{
    #ifdef A
        #ifdef B
        printf("1");//语句1
        #endif
        #ifdef C
        printf("2");//语句2
        #endif
    #endif
    #if A
        #if B
        printf("3");//语句3
        #elif C
        printf("4");//语句4
        #else
        printf("5");//语句5
        #endif
    #endif
    return 0;
}

条件编译指令的嵌套可以像理解if语句的嵌套那样去理解二者十分相似。

所以只有语句1,2,5参与编译。

下面是预编译后的代码：

程序环境和预处理_#endif_33

5、文件包含

5.1头文件的包含方式

①本地文件包含

#include"filename.h"

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。如果找不到就提示编译错误。

②库文件包含

#include<filename.h>

查找头文件直接去标准路径下查找，如果找不到就提示编译错误。

有一个疑惑，对于库函数，也可以使用“”的形式包含吗？

答案是可以，但是这样做的话，查找效率就低些，也不容易区分是库文件还是本地文件了。

5.2嵌套文件包含

如果出现这种情况

程序环境和预处理_预处理指令_34

comm.h和comm.c是公共模块。

tets1.c和test1.h使用了公共模块。

test2.c和test2.h使用了公共模块。

test.h和test.c使用了test1模块和test2模块。

这样最终程序中就会出现两份com.h的内容，这就造成了文件内容的重复

如何解决这个问题？

这就需要使用条件编译了，每个头文件这么写：

#ifndef __TEST__
#define __TEST__
//头文件内容
#

这样，在test模块中，如果第一次引用头文件，那么头文件__TEST__未定义，可以参与编译。当第二次引用这个头文件（重复引用），此时__TEST__已经被定义了，就不会参与编译，避免了头文件的重复引用。

或者：

#pragma once
//头文件内容

也可以避免头文件的重复引用。

  



本文结束。