程序环境和预处理

本章重点：

程序的翻译环境
程序的执行环境
讲解：C语言程序的编译+链接
预定义符号介绍
预处理指令#define
宏和函数的对比
预处理操作符#和##的介绍
命令定义
预处理指令#include
预处理指令#undef
条件编译

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

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

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

2.详解编译+链接

1，翻译环境

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

2，编译本身也分为几个阶段

查看代码每一步都发生了什么：（Linux操作系统,gcc程序）

1，预处理选项gcc test.c - E -o test.i

预处理完成之后就停下来将产生的结果放到放在test.i文件中

2，编译选项gcc test.c -S(gcc test.i - S,直接从test.i就是预处理后开始编译)（gcc test.c -S表示从预处理前就是从源文件开始编译）

编译完成后就停下来，结果保存在test.s中

3，汇编 gcc-c test.c

汇编完成后就停下来，结果保存在test.o中

编译这个过程的学习可以参考《编译原理》这个课程

和《程序员的自我修养》这本书。

VIM学习资料

简明VIM练级攻略
https://coolshell.cn/articles/5426.html

给程序员的VIM速卡
https://coolshell.cn/articles/5479.html

3，运行环境

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

3.预处理详解

1，预定义符号

FILE //进行编译的源文件

LINE //文件当前的行号

DATE //文件被编译的日期

TIME //文件被编译的时间

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

（对于这个gcc编译器为1，VS编译器未定义）

常用编译器：gcc clang（苹果维护的）

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

（我们写日志的话可以将日期写上去）

2，#define

2.1 #define定义的标识符

语法：

#define name stuff

cs 复制代码

#define MAX 100
#define reg register   //为register这个关键字创建一个简单的名字
#define do_forever for(;;)    //用更形象的符号来替换一种实现
#define CASE break;case    //写case语句的时候自动把break写上
//如果定义的stuff过长，可以分行写，除了最后一行外，每行的后面都加一个反斜杠（续行符）(续行符转义回车，让回车不是回车）
#define DEBUG_PRINT printf("file:%s\tiline:%d\t\
							date:%s\ttime:%s\n",\
							__FILE__,__LINE__,\
							__DATE__,__TIME__)

#define在预处理时就被替换，在VS编译器下也能看到预处理的结果

会在文件夹中产生.i的文件。

//可以了解一下国际乱码大赛

2.2#define定义的宏

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

下面是宏的申明方式：

#define name(parament-list）stuff

其中parament-list是一个由逗号隔开的符号表，他们可能出现在stuff中。

注意：
参数列表必须与name紧邻。

如果两者之间有任何空白的存在，参数列表就会被解释为stuff的一部分

cs 复制代码

#define SQUARE(X)  X*X

int main()
{
	int r = SQUARE(5);//5*5//25

	//int r = SQUARE(5 + 1); //5+1*5+1//11

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

}

cs 复制代码

#define DOUBLE(X)  (X)+(X)

int main()
{
	int a = 5;
	printf("%d\n", 10 * DOUBLE(a));//10*5+5=55
	return 0;
}

注意宏是完成替换的，不是完成计算的，所我们在使用的时候通常要在计算部分，和总的结果部分都加括号。

比如上述两段代码宏的定义我们都应该写成

#define SQUARE(X) ((X)*(X))

#define DOUBLE(X) ((X)+(X))

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

2.3#define替换规则

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

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

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

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

cs 复制代码

#define M 100
#define DOUBLE(X)  (X)+(X)

int main()
{
	DOUBLE(M + 2);//DOUBLE(100 + 2);
	//((100 + 2)+ (100 + 2))
	return 0;
}

注意：

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

cs 复制代码


#define M 100
#define DOUBLE(X)  (X)+(X)

int main()
{

	"M";
	"DOUBLE(3)";

	return 0;
}

2.4#和##

#是将宏参数变成对应字符串。

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

1，如何把参数插入到字符串中

首先我们需要知道字符串是可以分开输入的

观察一下代码

cs 复制代码

#include<stdio.h>

int main()
{
	int a = 10;
	print(a);
	printf("the value of a is %d\n", a);

	int b = 20;
	print(b);
	printf("the value of b is %d\n", b);
	return 0;
}

我们可以发现输出部分有很多重复的，但是我们写一个函数的话无论如何设计都不能把参数插入到字符串中，这个时候我们就可以定义一个宏来实现

cs 复制代码

#define print(N) printf("the value of "#N" is %d\n",N);
int main()
{
	int a = 10;
	print(a);
	//printf("the value of a is %d\n", a);

	int b = 20;
	print(b);
	//printf("the value of b is %d\n", b);
	return 0;
}

我们还可以通过宏打印不同类型的数据

cs 复制代码

#define print(N,FORMAT) printf("the value of "#N" is "#FORMAT "\n",N);
int main()
{
	int a = 10;
	print(a,%d);
	//printf("the value of a is %d\n", a);

	double b = 20.535;
	print(b,%lf);
	//printf("the value of b is %d\n", b);
	return 0;
}

##能把两边的符号合并成一个

2.5带副作用的宏参数

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

例如：

x+1;//不带副作用

x++;//带有副作用，用过之后x的值发生了改变

如我们是有一个三目操作符定义MAX

cs 复制代码

#include<stdio.h>

#define MAX(a,b) ((a)>(b)?(a):(b))
int main()
{
	int a = 5;
	int b = 4;
	int m = (a++, b++);
	//int m=((a++)>(b++)?(a++):(b++))

	printf("m=%d\n",m);
	printf("a=%d,b=%d\n", a, b);
	return 0;
}

分析这段代码：首先后置++先使用后++，5>4，错误进行（a++),这个时候a=6,b=5,，计算结果返回6，即m=6，（a++)后a=7

这个是时候就没有待会我们想要的两个数中较大的值

2.6宏和函数的对比

像上面代码我们用宏来找两个书中的叫大数

有两个好处

1.用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作需要的时间更多，所以宏，在时间上更胜一筹。（宏之间带入数值计算，函数需要创建函数栈帧，参数传参，计算，函数返回）

2.函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。繁殖这个宏可以适用于整形，长整型，浮点型等可以用来比较能用>来比较的任何类型，宏是类型无关的。更具有灵活性。

当然，宏和函数比也有劣势和缺点

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

2.宏是没法调试的（宏在预处理阶段就完成了数值的替换，但是调试是完成编译和链接，并生成可执行程序之后进行的）

3.由于类型无关，宏也不够严谨。

4.宏可能会带来运算符优先级的问题，导致程序容易出错。（使用宏的时候一定要多加括号）

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

cs 复制代码

#define MALLOC(num,type) malloc(num*sizeof(type));
int main()
{
    //malloc(40);
    //malloc(10, int);
    int* p= MALLOC(10, int);

    //int *p = malloc(10*sizeof(int));

    return 0;

}

宏和函数的对比

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常小的宏外，程序长度会大幅度增加	函数代码只出现于一个地方；每次使用这个函数时，都调用那同一个地方的函数。
执行速度	更快	存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级	宏参数的求值，是在所有周围表达式的上下文环境里，除非加上括号，否则临近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多写些括号	函数参数值在函数调用的时候求值一次，他的结果值传给函数，表达式求值的结果更容易预测。
带有副作用的参数	参数可能被替换到宏体中多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。	函数参数只在传参的时候求值一次，结果更容易控制。
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，他就可以适用于任何参数类型。	函数的参数是与类型有关的，如果参数类型不同，就需要不同的函数，即使他的执行任务是相同的。
调试	宏是不方便调试的	函数时可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

2.7命名约定

一般来讲，函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。那我么平时的一个习惯是：把宏名全部大写（MAX)，函数名不要全部大写(Max）

但是也有一些宏会用小写：例如offsetof，还有有写getchar也是用宏定义的。

3，#undef

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

#undef NAME

//如果现存的一个名字需要被重定义，那么它的就名字首先要被移除。

cs 复制代码

#define M 100

int main()
{
	printf("%d\n", M);
#undef M
	printf("%d\n", M);//识别不出来
	return 0;
}

4，命令行定义（Linux系统下gcc编译器下实现）

许多C语言编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器，内存大些，我们需要一个数组能够大些。）

cs 复制代码

#include<stdio.h>

int main()
{
	int arr[SZ];
	int i = 0;
	for (i = 0;i < SZ;i++)
	{
		arr[i] = i;
	}
	for (i = 0;i < SZ;i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

可以在gcc编译器下先定义SZ在运行：gcc test.c -D SZ=10 (回车）./a.out

gcc test.c -D SZ=100 (回车）./a.out

-D是定义，与SZ间的空格可有可无。

5，条件编译

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

比如说：调试性代码，像printf，删除可以，保留又碍事，我们可以选择性的编译

cs 复制代码

#include<stdio.h>
#define __DEBUG__//不需要的话直接将他注释掉

int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0;i < 10;i++)
	{
		arr[i] = i;
#ifdef __DEBUG__
		printf("%d ", arr[i]);
#endif //DEBUG
	}
}

1：

#if 常量表达式

//......

#endif

//常量表达式由于处理器求值

如：

#define DEBUG 1

#if BEBUG //为真执行

//......

#endif

#if 0//为真执行

//......

#endif

#if 2==3//为真执行

//......

#endif
2.多个分支的条件编译

#if 常量表达式

//......

#elif 常量表达式

//......

#else

//......

#endif

#define M 3

int main()

{

#if M<5

printf("good\n");

#elif M==5

printf("nice\n");

#else

printf("perfect\n");

#endif

return 0;

}
3.判断是否被定义

#if define(symbol)

#ifdef symbol

#if !define(symbol)

#ifndef symbol

//#define MAX

int main()

{

#if define(MAX)

printf("max\n");

#endif

return 0;

}

int main()

{

#ifdef MAX

printf("max\n");

#endif

return 0;

}
4.嵌套指令

#if defined(OS_UNIX)

#ifdef OPTION1

unix_version_option1();

#endif

#ifdef OPTION2

unix_version_option2();

#endif

#elif defined(OS_UNIX)

#ifdef OPTION2

unix_version_option1\2();

#endif

#endif

在头文件中会有很多这样的嵌套指令

6，文件包含

6.1头文件包含

我们已经知道，#include指令可以使另外一个文件被编译。就像它实际出现于#include指令的地方一样。

这种替换方式很简单：

预处理器先删除这条指令，并用包含文件的内容替换。

这样源文件被包含10次，那就是即被编译10次

我们在写自己的头文件的时候有两种方法可以避免头文件被多次包含

cs 复制代码

#ifndef __TEST_H__
#define __TEST_H__
int ADD(int x, int y);
#endif

cs 复制代码

#pragma once
int ADD(int x, int y);

之前我们在说引用库里的头文件的时候用<>,引用自己的头文件用""

<>和""的区别是查找策略不同

#include<stdio.h>

<>查找策略：直接去库目录下查找

#include"test.h"

""查找策略：

1.先去代码所在的路径下查找。

2.如果上面找不到，再去库目录下查找。

查找库文件也可以用"",但是效率低，最好不用。

6.2嵌套文件包含

防止头文件被嵌套包含，我们可以采用上面两种方式来避免。

在《高质量C/C++编程指南》中附录的考试试卷（很重要）

就有这样两道题

1.头文件中的ifndef/define/endif是干什么用的

2.#include<filename.h>和#include"filename.h"的区别

4.其他预处理指令

#error

#pragma

#line

......

#pragma pack()在结构体部分介绍

参考《C语言深度解剖》学习。