【C】程序环境和预处理

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

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

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

翻译环境

翻译环境我们主要解释一下编译和链接过程。

我们的源文件也就是我们的.c文件通过编译器生成一个目标文件（windows是.obj，Linux是.o）后缀的文件，我们一个工程会有多个.c文件，所以也就会有多个目标文件，他们通过链接器的链接然后与链接库（静态库）一起生产我们的可执行程序也及时.exe的文件。

总结一下：

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

编译

编译又分为三个阶段，预编译、编译、汇编。

预编译

预编译程序都做什么事情呢？

删除所有的注释。
#include头文件的包含。
#define 符号的替换。
所有预处理指令的操作。

编译

在这个过程中我们的程序做什么事情呢？

将我们的代码翻译成汇编指令。
语法分析
词义分析
语义分析
符号汇总

汇编

在这个过程中我们的程序又做什么事情呢？

将我们的汇编指令翻译成计算机能够读懂的二进制指令
形成符号表
生成我们的目标文件

链接

由于我们的多个目标文件都有自己的符号表，以及各种段所以在链接中主要进行：

合并段表
符号表的合并以及符号的重定位（有实际意义的地址）

执行环境

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

预处理

预定义符号

这些预定义符号都是语言内置的。

代码演示：

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

运行结果：

#define

定义标识符

语法：

#define name stuff

给大家举几个例子：

#define M 100
#define FOR for(;;)
#define uint unsigned int
#define CASE break;case

这些定义方法都是可以的，后面可以是一个数字，也可以是一个类型，甚至可以是一段代码，这样都是可以的。

在define定义标识符的时候，要不要在最后加上 ; ?

建议不要加上 ; ,这样容易导致问题。

定义宏

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

语法：

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

注意：

参数列表的左括号必须与name紧邻。 如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。
例如：#define SQUARE( x ) x * x

我们在定义宏的时候，最好将每个数都带一个括号，然后最后整体在加一个括号，为什么要这样做呢？
我们来看一段代码：

#include <stdio.h>

#define DOUBLE(x)  x*x
#define DOUBLE1(x)  ((x)*(x))
int main()
{
    
    
	printf("%d\n", DOUBLE(3));     // 我们预期是9
	printf("%d\n", DOUBLE(3+2));  // 我们预期是25
	printf("%d\n", DOUBLE1(3));   // 我们预期是9
	printf("%d\n", DOUBLE1(3+2)); // 我们预期是25
	return 0;
}

运行结果：

我们可以看到第二次计算的结果和我们的不一样，那这是为什么呢？
实际上我们#define在运算时，会将内容替换进去，我们实际上执行的是：

3+2*3+2

这段代码。所一结果就是11，这也就是为什么我在定义宏的时候要将每个数都带一个括号，然后最后整体在加一个括号的原因了，不然会出现意想不到的结果。

#define的替换规则

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

注意：

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

#和##

这里给大家铺垫一个知识，就是说我们想在屏幕上打印Hello world时我们肯定会这样去写：

printf(“Hello world\n”);

其实下面这种写法也是可以的，我们C语言是支持这样写的

printf("Hello "“world\n”);

1.#的作用

使用 # ，把一个宏参数变成对应的字符串。

代码演示：

#include <stdio.h>
#define PRINT(s) printf("the " #s " is %d",s)
int main()
{
    
    
	int value = 10;
	PRINT(value);
	return 0;
}

运行结果：

2. ##的作用

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

代码演示：

#include <stdio.h>
#define s(a,b) a##b
int main()
{
    
    
	int num123 = 2019;
	printf("%d\n", s(num, 123));
	return 0;
}

运行结果：

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

带有副作用的宏参数

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

因为宏是替换的，所以x++就可能会到导致x多次变化，无法预知。

宏和函数的对比

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

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

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

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

命名约定

把宏名全部大写 函数名不要全部大写

#undef

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

命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。 例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）

条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。
比如说：
调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

常见的条件编译指令：

#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 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
这种替换的方式很简单： 预处理器先删除这条指令，并用包含文件的内容替换。 这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式：
1.本地文件包含

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

2.库文件包含

#include <filename.h>
查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

这样是不是可以说，对于库文件也可以使用 “” 的形式包含？

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

嵌套头文件包含

嵌套头文件包含会造成文件内容重复，怎么解决这个问题呢？
每个头文件的开头写：

#ifndef TEST_H
#define TEST_H
//头文件的内容
#endif //TEST_H

或者

#pragma once

就可以避免头文件的重复引入。

今天的内容就分享到这里，感谢大家的关注和支持。