【C语言】程序环境与预处理
目录
程序的翻译环境和执行环境
粗谈编译+链接
翻译环境
编译的几个阶段及链接
运行环境
预处理详解
预定义符号
#define
#define 定义标识符
#define 定义宏
#define 替换规则
#和##
带副作用的宏参数
宏和函数的对比
命名约定
#undef
命令行定义
条件编译
文件包含
头文件被包含的方式
程序的翻译环境和执行环境
在ANSI C（标准C）的任何一种实现中,存在两个不同的环境。
第一种是翻译环境,在这个环境中源代码（.c 文件）被转换为可执行的机器指令（二进制指令，.exe文件）。
（VS->生成->生成解决方案）
VS 是集成开发环境，在以上过程中，它充当了翻译环境。
第二种是执行环境,它用于实际执行代码。
计算机只能执行二进制指令
粗谈编译+链接
翻译环境
● 组成一个程序的每个源文件（.c) 都单独通过编译器分别转换成目标代码(object code , obj)。
● 每个目标文件由链接器 (linker) 捆绑在一起,形成一个单一而完整的可执行程序。
● 链接器同时也会引入标准C函数库中任何被该程序所用到的函数,而且它可以搜索程序员个人的程序库,将其需要的函数也链接到程序中。
编译的几个阶段及链接
编译还可以分为三个阶段：预编译（预处理）、编译和汇编。
各个阶段的工作：
预处理阶段：1、头文件的包含 2、define 符号替换和删除 3、注释的删除 ，这些都是文本操作，最终生成 .i 文件。
编译阶段：（详见《编译原理》）进行语法分析、词法分析、语义分析、符号汇总（符号汇总：记录全局变量名、自定义函数名和 main 函数名）, 把代码翻译成汇编代码。生成 .s 文件
汇编阶段：把汇编代码翻译成二进制指令，生成目标文件（gcc 是 .o 文件，VS 是 .obj 文件），二进制指令存放在目标文件，并形成符号表（符号汇总时的符号和它们的地址所形成的表格）。
经过编译阶段，每个源文件都生成了对应的目标文件
接下来是链接：
1、合并段表
2、符号表的合并和重定位（每个目标文件都形成了一个符号表，这些符号表可能有一些符号的地址是无效的，比如 main 函数中 extern int Add（int x，int y），声明外部函数 Add ，Add 在 main 函数的源文件所生成的符号表的地址就是无效的，通过合并符号表将无效的地址重定位,如果在链接时发现有无效地址，就会报出“无法解析的外部符号”）
运行环境
程序执行的过程:
1. 程序必须载入内存中。在有操作系统的环境中:一般这个由操作系统完成。在独立的环境中,程序的载入必须由手工安排,也可能是通过可执行代码置入只读内存来完成。
2. 程序的执行便开始。接着便调用main函数。
3. 开始执行程序代码。这个时候程序将使用注体运行时堆栈（函数栈帧）(stack),存储函数的局部变量和返回地址。程序同时也可以使用静态(static)内存,存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。4.终止程序。正常终止main函数;也有可能是意外终止。
（推荐阅读：《程序员的自我修养》）
预处理详解
预定义符号
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C,其值为1,否则未定义这些预定义的符号都是语言内置的。（__FILE__，__ 是两个下划线）
VS 编译器不认识 __STDC__，说明 VS 编译器不遵循 ANSI C 标准，而 gcc 是遵循 ANSI C 标准的。
这些符号在预处理阶段都被替换了
.i 文件：
# 1 "test.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "test.c"
# 32 "test.c"
int main()
{
printf("%s\n", "test.c");
printf("%d\n", 35);
printf("%s\n", "Feb 8 2023");
printf("%s\n", "16:22:58");
printf("%d\n", 1);
return 0;
}
#define
#define 是一个预处理指令，常见的预处理指令还有：#include、#pragma等。
#define 定义标识符
功能：
#define A B
在预处理时，程序中凡是出现 A 的地方都替换为 B。（B 后面最好不要加分号，因为分号也会替换 A，总会出现语法错误）
例子：
#define MAX 1000
#define reg register //为 register这个关键字,创建一个简短的名字
#define do_forever for( ;; ) //用更形象的符号来替换一种实现
#define CASE break; case //在写case语句的时候自动把 break写上。
// 如果定义的 stuff过长,可以分成几行写,除了最后一行外,每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
date:%s\ttime:%s\n" , \
__FILE__ , __LINE__ \
__DATE__ , __TIME__ )
#define 定义宏
#define 机制包括了一个规定,允许把参数替换到文本中,这种实现通常称为宏(macro)或定义宏(define macro)。
下面是宏的申明方式:
#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表,它们可能出现在stuff中。
注意:参数列表的左括号必须与name紧邻。如果两者之间有任何空白存在,参数列表就会被解释为stuff的一部分。
例子：
#define SQUARE(X) X*X
int main()
{
printf("%d\n", SQUARE(5));
printf("%lf\n", SQUARE(5.0));
return 0;
}
定义了一个求平方的宏，在预处理时凡是遇到 SQUARE(X) 的地方都被替换为 X*X（只是替换为 X*X，在预处理时不会计算 X*X 的值）。
X 被替换为 5 是非常机械的，SQUARE(5) 被替换为 5*5，SQUARE(M) 被替换为 M*M，而SQUARE(5+1) 并不会被替换为 （5+1）*（5+1），而是 5+1*5+1。所以不能把宏当成函数来使用。我们可以将上面的宏改写成 #define SQUARE(X) （(X)*(X)），可以解决问题。宏参数的求值是在所有周围表达式的上下文环境里,除非加上括号,否则邻近操作符的优先级可能会产生不可预料的后果,所以建议宏在书写的时候多些括号。
#define 替换规则
在程序中扩展#define定义符号和宏时,需要涉及几个步骤。
1. 在调用宏时,首先对参数进行检查,看看是否包含任何由 #define 定义的符号。如果是,它们首先被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏,参数名被他们的值所替换。
3. 最后,再次对结果文件进行扫描,看看它是否包含任何由 #define 定义的符号。如果是,就重复上述处理过程。
注意:
1. 宏参数和 #define 定义中可以出现其他 #define 定义的符号。但是对于宏,不能出现递归。
2. 当预处理器搜索 #define 定义的符号的时候,字符串常量的内容并不被搜索（字符串中由 #define 定义的标识符不被替换）。
#和##
#include <stdio.h>
int main()
{
printf("Hello ""world\n);
return 0;
}打印的结果是 Hello world，我们发现字符串是有自动连接的特点。
#include <stdio.h>
#define PRINT(X) printf("X:%d",X)
int main()
{
int a = 10;
PRINT(a);
return 0;
}在以上代码中，我们想要的效果是：将“X：%d”中 X 也被当成参数替换，最后打印的结果是 a：10，但实际打印的结果是 X:10 ，这时候就可以使用 # 了。
#的作用：将宏中的字符变为宏的参数，在该字符两边加上引号，使之边变为字符串形式，但这个字符不能在字符串中，就像这样：
#include <stdio.h>
#define PRINT(X) printf(#X":%d",X)
int main()
{
int a = 10;
PRINT(a);
return 0;
}printf(#X":%d",X) 会被替换成 printf( ”X“ ":%d",X)，X 是一个字符串，:%d 是一个字符串。上面代码中 X 的实参是 a，则 PRINT(a) 会被替换为 printf("a" " :%d", a) 。
运用 # ，我们再增加一个参数，使 PRINT 可以打印按其他格式打印数据：
#include <stdio.h>
#define PRINT(format,X) printf(#X":"#format"\n",X)
int main()
{
int a = 10;
PRINT(%d,a);
float b = 1.1f;
PRINT(%f, b);
return 0;
}##可以把位于它两边的符号合成一个符号。它允许在宏定义中创建标识符。创建的标识符必须是合法的，否则其结果是未定义的。
例子：
#define ADD_TO_SUM(num, value) \
sum##num += value;
...
ADD_TO_SUM(5, 10);//作用是:创建 sum5 变量，给sum5增加10.
# 和 ## 只能在定义宏时使用。
带副作用的宏参数
当宏参数在宏的定义中出现超过一次的时候,如果参数带有副作用,那么你在使用这个宏的时候就可能出现危险,导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
例如:
x+1;//不带副作用
x++;//带有副作用以下的宏可以证明具有副作用的参数所引起的问题。
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
#include <stdio.h>
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;
}分析：int z = MAX(x++,y++); 这条语句在预处理时被替换为了：
int z = ((x++) > (y++) ? (x++) : (y++))，因为 5 > 8 为假，所以表达式的值就是 y++，
（此时 x = 6，y = 9）将 y = 9 赋值给 z 后，y = 10。
宏和函数的对比
宏通常被应用于执行简单的运算。比如在两个数中找出较大的：
#define MAX(a, b) ((a)>(b)?(a):(b))那为什么不用函数来完成这个任务 ? 原因有二:
1. 用于调用函数和从函数返回值的时间可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏可以适用于整形、长整型、浮点型等数据类型，宏是类型无关的。
宏的缺点:当然和函数相比宏也有劣势的地方:
1. 每次使用宏的时候,一份宏定义的代码将插入到程序中。除非宏比较短,否则可能大幅度增加程序的长度。
2.宏是没法调试的。
3. 宏由于类型无关,也就不够严谨。4. 宏可能会带来运算符优先级的问题,导致程序容易出现错。
宏还可以做到函数做不到的事情，比如简化 malloc 函数调用：
我们在调用 malloc 函数时，一般是这样调用的：
int* p = (int*)malloc(10*sizeof(int));我们会觉得这样写太繁琐了，能不能直接写成：malloc(10,int) 呢？借助宏就可以：
#define MALLOC(num, type) (type*)malloc(num*sizeof(type))命名约定
一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。那我们平时的一个习惯是:
把宏名全部大写
函数名不要全部大写
#undef
这条指令用于移除一个宏定义。
#undef NAME
//如果现存的一个名字需要被重新定义,那么它的旧名字首先要被移除。
命令行定义
许多C的编译器提供了一种能力,允许在命令行中定义符号。用于启动编译过程。例如:当我们根据同一个源文件要编译出一个程序的不同版本的时候,这个特性有点用处。(假定某个程序中声明了一个某个长度的数组,如果机器内存有限,我们需要一个很小的数组,但是另外一个机器内存大些,我们需要一个数组能够大些。)
条件编译
在编译一个程序的时候我们如果要将一条语句(一组语句)编译或者放弃是很方便的。因为我们有条件编译指令。
比如说:
调试性的代码,删除可惜,保留又碍事,所以我们可以选择性的编译。
例子：
//#define PRINT 1
int main()
{
#ifdef PRINT
printf("hehe\n");
#endif
return 0;
}作用：如果定义了 PRINT 符号，就编译 #ifdef 和 #endif 之间的代码，否则不编译。
常见的条件编译指令：
1.
#if 常量表达式
// ...
#endif
//常量表达式由预处理器求值。如:
#define __DEBUG__ 1
#if __DEBUG__
//...
#endif2.多个分支的条件编译
#if 常量表达式
// ...
#elif 常量表达式
// ...
#else
// . ..
#endif与 if-else 结构类似
3.判断是否被定义
#if defined(symbol)//如果定义了symbol，就为真，而不关心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在大型的工程中，头文件可能无意间被多次包含，造成代码冗余和编译效率下降的问题，此时我们可以使用条件编译来避免：
某头文件：
#ifndef __TEST_H__
#define __TEST_H__
int Add(int x, int y);
#endif或者：
#pragma once文件包含
我们已经知道,#include 指令可以使另外一个文件被编译。就像它实际出现于#include 指令的地方一样。
这种替换的方式很简单:
预处理器先删除这条指令,并用包含文件的内容替换。这样一个源文件被包含10次,那就实际被编译10次。
头文件被包含的方式:
● 本地文件包含
#include "filename"查找策略:先在源文件所在目录下查找,如果该头文件未找到,编译器就像查找库函数头文件一样在标准位置查找头文件。如果找不到就提示编译错误。
Linux环境的标准头文件的路径:
/usr/includeVS环境的标准头文件的路径:
C:\Program Files (x86)\Microsoft visual Studio 12.0\vc\include //这是vs2013的默认路径● 库文件包含
#include <filename.h>查找策略:查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说,对于库文件也可以使用“ ”的形式包含?答案是肯定的,可以。
但是这样做查找的效率就低些,当然这样也不容易区分是库文件还是本地文件了。