程序的翻译环境
在ANSI C的实现中，存在两个不同的环境：翻译环境和执行环境。
翻译环境中源代码被转换为可执行的机器指令，执行环境用于实际执行代码。
翻译环境：
链接库：调用某一个函数时，会把和该函数相关的几个库一起链接进去。
组成一个程序的每个源文件通过编译过程分别转换成目标代码，每个目标文件由链接器捆绑在一起，形成一个单一而完整的可执行程序，链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。
编译阶段
在CentOS上写如下test.c程序：
（1）预处理阶段:
执行gcc test.c -E>test.i
执行vim test.i查看.i文件，滚动到底部可以看到红色框内的代码，前面都是预处理时替换的内容，MAX(a,b)也被替换为((100)>(200)?(100):(200))，且注释不见了。
以蓝色框内flockfile、ftrylockfile、funlockfile函数为例查看预处理时是如何替换库函数的：查看/usr/include/下的头文件
vim 查看stdio.h文件，滚动到底部，可以看到flockfile、ftrylockfile、funlockfile函数，预处理使用stdio.h的内容将#include<stdio.h>替换了
这说明执行gcc test.c -E>test.i做了3件事：1.完成头文件的包含，2#define定义的宏的替换，3.删除注释。
（2）编译阶段
执行gcc test.i -S
vim test.s，可以看到里面都是汇编代码
编译阶段主要把C语言代码转化成汇编代码，包括语法分析、词法分析、语义分析、符号汇总。
（3）汇编阶段
执行gcc test.s -c，生成test.o文件
test.o文件时elf格式的，使用readelf工具查看，执行readelf test.o -s查看test.o文件，生成的符号名有g_val、Add、main、printf分别对应源文件的全局变量和函数。
汇编阶段把汇编代码转换成机器指令(二进制指令)生成目标文件，形成符号表。
链接阶段
将test.c中Add函数的执行放在add.c文件中：
test.c
add.c
编译成目标文件，查看目标文件：
test.o
add.o
可以看到test.o和add.o中的符号表都包含Add，但是test.o中的Add函数没有意义，只是声明而已。在链接阶段会合并段表，并进行符号表的合并和重定位。
编译链接阶段的执行过程：
程序的运行环境
2. 程序的执行便开始。接着便调用main函数。
3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。
4. 终止程序。正常终止main函数；也有可能是意外终止。
预定义符号介绍
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
打印以上信息可以帮助代码调试，如在哪个函数内部，什么时间打印等。
如新建log.txt文件，写以下代码，将调试信息输出到log.txt中。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
printf("%s\n", __FILE__);
printf("%d\n", __LINE__);
printf("%s\n", __DATE__);
printf("%s\n", __TIME__);
printf("%s\n", __FUNCTION__);
int i = 0;
FILE* pf = fopen("log.txt", "a+");
if (pf == NULL)
{
perror("fopen\n");
return 1;
}
for (i = 0; i < 10; i++)
{
fprintf(pf, "%s %d %s %s %d\n", __FILE__, __LINE__, __DATE__, __TIME__, i);
}
fclose(pf);
pf = NULL;
return 0;
}ctrl+F5运行后，打开log.txt文件
预处理指令#define
语法：
#define name(parament-list) stuff
对于(1)这是因为给#define语句加上分号，相当于两条语句，有时候加上分号还会出错。如下面代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#define M 1000;
int main()
{
int a = 10;
int b = 0;
if (a > 10)
b = M;
else
b = -M;
printf("%d", b);
return 0;
}代码报错：
这是因为语法认为分号前面应该加上语句，而代码里面；前面没有语句else会报错。
对于(3)有如下代码：
#define _CRT_SECURE_NO_WARNINGS 1
#define SQUARE(X) X*X
int main()
{
printf("%d\n", SQUARE(3+1));
return 0;
}
打印结果为7
这是因为SQUARE(3+1)宏替换的表达式为3+1*3+1=7,而不是预想中的16。因此stuff带上括号会避免宏替换的错误执行结果，上面的宏定义为下面的写法，计算结果就会为16。
#define SQUARE(X) (X*X) 在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。
另外，还需要注意：
1. 宏参数和#define 定义中可以出现其他#define定义的变量。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。
预处理操作符#和##
# 把宏参数变成对应的字符串
对于把参数插入到字符串中的需求，如想打印 the value of "a" is 10，如下代码会报错
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#define PRINT(X) printf("the value of "X" is %d",x)
int main()
{
int a = 10;
PRINT(a);
//printf("the value of "a" is %d",a);
return 0;
}这里会报错
这里需要在宏定义X前面加上#
#define PRINT(X) printf("the value of "#X" is %d",X)再执行代码：
##可以把位于它两边的符号合成一个符号。 它允许宏定义从分离的文本片段创建标识符。
如下代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#define JOINT(X,Y) X##Y
int main()
{
int JustDOIT = 32;
printf("%d\n", JOINT(Just, DOIT));
return 0;
}实际上Just##DOIT经过合成后变成JUSTDOIT，打印32。
注意： 连接必须产生一个合法的标识符。否则其结果就是未定义的。
当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用(表达式求值的时候出现的永久性效果)，使用宏时就可能出现危险，导致不可预测的后果。
如下代码有副作用：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#define MAX(X,Y) ((X) > (Y) ? (X):(Y))
int main()
{
int a = 5;
int b = 8;
int m = MAX(a++, b++);
printf("%d\n", m);//9
return 0;
}
打印结果为9
宏和函数的对比
宏通常被应用于执行简单的运算。比如在两个数中找出较大的一个 ：
#define MAX(a, b) ((a)>(b)?(a):(b))宏相对于函数的优势：
（1）用于调用函数和从函数返回的代码可能比实际执行函数计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
（2）函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。而宏可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。
宏相对于函数的不足：
1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
2. 宏是没法调试的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。
宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到
#define MALLOC(num, type) (type *)malloc(num * sizeof(type))
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));宏和参数对比：
| 属性 | #defifine定义宏 | 函数 |
| 代码长度 | 每次使用时，宏代码都会被插入到程序中。除了非常小的宏 之外，程序的长度会大幅度增长 | 函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码 |
| 执行速度 | 更快 | 存在函数的调用和返回的额外开销， 所以相对慢一些 |
| 操作符优先级 | 宏参数的求值是在所有周围表达式的上下文环境里，除非加 上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号 | 函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测 |
| 带有副作用的参数 | 参数可能被替换到宏体中的多个位置，所以带有副作用的参 数求值可能会产生不可预料的结果 | 函数参数只在传参的时候求值一次，结果更容易控制。 |
| 参数类型 | 宏的参数与类型无关，只要对参数的操作是合法的，它就可 以使用于任何参数类型 | 函数的参数是与类型有关的，如果参 数的类型不同，就需要不同的函数， 即使他们执行的任务是不同的 |
| 调试 | 宏是不方便调试的 | 函数是可以逐语句调试的 |
| 递归 | 宏是不能递归的 | 函数是可以递归的 |
注意： 把宏名全部大写 函数名不要全部大写，用于区分函数和宏。
条件编译
使用条件编译指令可以将部分语句编译或放弃，例如，调试性的代码，删除可惜，调试又碍事，因此可以选择性地编译。
#define _CRT_SECURE_NO_WARNINGS 1
#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\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__
}
return 0;
}当屏蔽第3行代码#define __DEBUG__时，编译时会把下面这几行代码删掉。
#ifdef __DEBUG__
printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__ 如果放开第3行的代码上面这3行代码会被执行，会打印数组的值。
常见的条件编译指令：
（1） #if 常量表达式
//...
#endif
#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 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。这种替换的方式很简单： 预处理器先删除这条指令，并用包含文件的内容替换。 这样一个源文件被包含10次，那就实际被编译10次。
头文件被包含的方式有两种：
（1）本地文件包含
#include "filename"查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。如果找不到就提示编译错误。
/usr/includeVS环境的标准头文件的路径（即安装路径）：
C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include（2）库文件的包含
#include <filename.h>查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。 对于库文件也可以使用" "的形式包含？ 但是这样做查找的效率低，也不容易区分包含的是库文件还是本地文件。
嵌套文件包含：
（1）条件编译
#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__（2）pragma
#pragma once
扫一扫
873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
