程序员进阶之路：程序环境和预处理

 文章来源地址https://www.toymoban.com/news/detail-601421.html

目录

前言

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

翻译环境

运行环境

预处理（预编译）

预定义符号

#define

#define 定义标识符

#define 定义宏

 #define 替换规则

 #和##

 #的作用

##的作用

 带副作用的宏参数

 宏和函数对比

命名约定

 #undef

命令行定义

条件编译 

文件包含

 嵌套文件包含

总结

前言

程序员的日常工作离不开程序环境和预处理，本文将为您详细解析它们的内部机制和运作原理。

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

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

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

 什么意思呢？

计算机只能执行二进制指令，我们写的C语言程序属于文本信息，计算机不能直接理解

翻译环境：在这个环境中就是将C语言代码翻译成二进制指令，这些指令会放在可执行程序当作。

执行环境：当我们得到可执行程序时，如何让它运行起来呢？这时就需要到执行环境，执行环境就是用来执行二进制的代码。

翻译环境的整体流程如下：

 我们写的每一个.c文件都属于源文件。一个项目当中可以包含多个.c文件。在翻译环境中，每个源文件会单独的经过编译器处理，生成目标文件（.obj文件)，每个目标文件与链接器捆绑在一起，形成一个单一而完整的可执行程序。

那链接器的作用是什么呢？

链接器会引入标准C函数库中被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。

翻译环境

 在翻译环境下，计算机会进行两大操作，一个是编译，一个是链接。

编译又可分为3个阶段：

 在开始编译后，会先进入预编译阶段，预编译阶段会做什么呢？这些我们在VS这种集成开发环境中是看不到的。有使用vscode的小伙伴可以试一试。

例如我们写一个简单的程序并进行预处理，如下图：

 输入指令让程序先进行预处理，预处理后我们可以看到在我们写的代码前多了800多行代码，这800多行代码是怎么来的呢？其实这增加的代码是我们包含的头文件s t d i o . h里的内容。

那在预处理阶段，计算机都对程序做了什么呢？主要做了一下三个操作：

• 注释的删除
• #include 头文件的包含
• #define 符号的替换

 这些都属于文本操作，所有的预处理指令都是在预处理阶段处理的。

 如下图，左边为翻译后的汇编指令。

预处理之后，程序就会进入编译阶段，编译阶段会将我们写的C语言代码翻译成汇编指令，它主要会对C程序进行一下操作：

• 语法分析
• 词法分析
• 语义分析
• 符号汇总

 编译之后程序进入汇编阶段，汇编阶段就会生成目标文件。目标文件中存放的都是二进制指令。

所以在汇编阶段，计算机主要干了一件事：把汇编代码，翻译成机器可以读懂的二进制指令。

 目标文件一般是不打开的，如果要强制打开，看到的也只是一些乱码。

在汇编阶段其实有一个动作叫：形成符号表

 在编译阶段程序会进行符号汇总，汇编阶段又会进行形成符号表的操作。这有什么用呢？

其实它们最终的用途是在链接阶段。在链接阶段，就会去查看这个符号表

在链接阶段会进行一下两个操作：

• 合并段表
• 符号表的合并和符号表的重定位

 这两个操作主要干什么呢？

我们可以先写一个简单的程序来观察：

在我们生成目标文件时，我们可以打开生成的这个二进制文件，打开文件之后，虽然说大部分东西都看懂，但是我们可以找到一个 E L F

 这种二进制文件看似乱码，实则具有自己的组织格式。在Linux环境下都是使用ELF这种组织格式来存储的。我们以Linux环境下为例。

核心就是，像elf这种组织格式，它的存储方式其实是将数据划分为一个一个的段，按照不同的段来存储（数据段，文本段，只读数据段等）。

 也可以输入指令去读这个二进制文件中的符号，打开我们可以看到一个个的全局符号

 在编译阶段，就已经进行了这些全局符号的汇总。

我们分两个文件去写程序：

test.c

extern int Add(int, int);
int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	printf("%d", c);
}

 add.c

int Add(int x, int y)
{
	return x + y;
}

 在编译时就会对两个文件中的符号进行汇总，add.c里边汇总一个符号Add，test.c文件汇总两个符号Add和main。

编译后进入汇编阶段，汇编阶段形成符号表，符号表里边存放的是汇总的符号，以及相应的地址。

 这里回到链接阶段的两个操作：

合并段表，我们前边知道在汇编阶段，生成的二进制文件，数据存储是分段存储的。上述我们使用两个文件来写程序，两个文件都是这样分段存储的。

到了链接阶段，两个文件合并对应位置上的数据段，并生产.exe结尾的可执行程序，它也是符合elf这样的分段存储。

还有符号表的合并，在add.c中汇总一个符号Add，有函数定义为有效地址，test.c中Add仅仅是一个声明，所以并不是一个有效地址，两个文件的符号表也会在链接阶段进行合并，生成一个新的符号表 

 这有什么用呢？在程序运行时，就会通过符号表上的地址去找到对应的函数。

 这整个过程就是程序在编译、链接生成可执行程序的整个过程。

运行环境

程序执行的过程：

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

预处理（预编译）

预定义符号

__FILE__    //进行编译的源文件

__LINE__   //文件当前的行号

__DATE__   //文件被编译的日期

__TIME__   //文件被编译的时间

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

 

 这些预定义符号都是语言内置的。 举个栗子：

int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);


	return 0;
}

 这些符号都是在预处理阶段处理的。

我们把代码拿到Linux系统下，进行预处理：

 我们发现预处理之后，预处理指令直接就被替换了。

#define

#define 定义标识符

举个例子：

#define N 100
#define STR "abcdef"
#define FOR for(;;)
#define reg register
#define CASE break;case
int main()
{
	int input = 0;
	printf("%d\n", N);
	printf("%s", STR);
	switch (input)
	{
	case 1:
	CASE 2:
	CASE 3:
			;
	}
	FOR;
}

 在程序运行时，N就会被替换成100，STR被替换成abcdef，FOR被替换成for（；；）也就是死循环，reg被替换成register(变量类型，寄存器变量），CASE 2：被替换成break；case 2：。

 这样的方法是可行的，缺点就是当标识符部分有错误时，程序出现报错，无法具体到位置。

提问：

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

答案是最好别加。

为什么呢？我们举个例子来看：

 这样的逻辑表面上 没有什么问题，但是编译器已经向我们报错了

 当程序进行预处理时，将N替换成100；，b=N；就会变成b=100；；，这样if后边就变成了两个语句，if在没有{}括住的情况下，后边最多只能有一条语句，所以运行时程序就会报错。

尽量定义标识符时不要加；

#define 定义宏

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

宏的申明方式：

 #define name( parament-list ) stuff 

 name是宏的名字，parament-list是参数列表，parament-list它们可能替换到stuff内容里边。

 我们直接上代码：

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

int main()
{
	int a = 0;
	int b = 1;
	int c = MAX(a, b);
	printf("%d", c);
	return 0;
}

 MAX就是定义的宏，在程序预处理后就会被替换，如下图：

 很类似于函数，但又与函数不同。

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

此外我们还要注意定义宏时常见的错误：

例如我们定义一个宏求一个数的平方：

#define SQUARE( x ) x * x

 上述声明之后，我们传进去一个5：

SQUARE( 5 );

 在程序运行后就会被替换成5*5.

但是如果这样写呢？

int a = 5;
printf("%d\n" ,SQUARE( a + 1) );

 乍一看，你可能觉得这段代码将打印36这个值。 事实上，它将打印11. 为什么？
替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了： printf ("%d\n",a + 1 * a + 1）；

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。
在宏定义上加上两个括号，这个问题便轻松的解决了：

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

 这样预处理之后就产生了预期的效果：

printf ("%d\n",(a + 1) * (a + 1) );

 这里还有一个宏定义：

#define DOUBLE(x) (x) + (x)

 定义中我们使用了括号，想避免之前的问题，但是这个宏仍然可能会出现新的错误。比如：

int a = 5;
printf("%d\n" ,10 * DOUBLE(a));

 看上去，好像打印100，但事实上打印的是55. 替换之后：

printf ("%d\n",10 * (5) + (5));

 乘法优先级高于加法，所以结果就成了55.

这个问题，的解决办法是在宏定义表达式两边加上一对括号就可以了：

#define DOUBLE( x) ( ( x ) + ( x ) )

 总结：

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

 #define 替换规则

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

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

 注意：

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

 #和##

那么如何把参数插入到字符串中？

 #的作用

int main()
{
	int a = 10;
	printf("the value of a is %d", a);
	int b = 20;
	printf("the value of b is %d", b);
	return 0;
}

 例如这样，我们理想输出是the value of a is 10，the value of b is 20；

 但是这样写多个的话又很麻烦，能不能封装成一个函数呢？

当去实现的时候我们会发现，实现不了，因为打印的时候只可以把数值修改了，前边的变量名并不能随意变换。

显然函数是无法做到的，但是宏却可以做到

怎么写呢？

#define PRINT(n) printf("the value of "#n" is %d\n",n)
int main()
{
	int a = 10;
	PRINT(a);
	int b = 20;
	PRINT(b);
	return 0;
}

 我们可以使用 # ，把一个宏参数转化成对应的字符串。

 但是这样仍然有局限性，它只能打印整形，不能打印浮点型数据啊。

于是我们可以这样修改：

#define PRINT(n,format) printf("the value of "#n" is"format"\n",n)
int main()
{
	int a = 10;
	PRINT(a, "% d" );
	int b = 20;
	PRINT(b," % d");
	float c = 3.14f;
	PRINT(c, " % f");
	return 0;
}

##的作用

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

 举个例子：

#define CAT(x,y) x##y
int main()
{
	int cc = 10;
	printf("%d", CAT(c, c));
	return 0;
}

输出结果是10，它可以把位于它两边的符号合成一个符号。在预处理时，就会将从c，c合成一个片段替换为cc。

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

#和##只可以在宏里边用。

 带副作用的宏参数

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

y=x+1;//不带副作用
y=x++;//带有副作用

虽然两种方法赋值给y的结果相同，但是第二种方法在赋值的同时，自身的大小也发生了变化。

MAX宏可以证明具有副作用的参数所引起的问题。

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
	int x = 5;
	int y = 6;
	int z = MAX(x++, y++);
	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
	return 0;
}

 程序运行，MAX会被替换成（（x++）>（y++）？（x++）：（y++））；在判断a和b大小之前，x是5，y是6.条件为假，就不执行（x++），执行（y++），判断后x是6，y是7，此时赋给z的值就变成了7，再次执行y++后y就变成了8。所以最终输出为6，8，7

从这里我们可以知道如果传给宏的参数带有副作用，那副作用就会在宏中延续，这也间接的表明宏的传参和函数传参的不同。

 宏和函数对比

宏通常被应用于执行简单的运算。比如在两个数中找出较大值。

那为什么不用函数来完成这个任务？ 原因有二：

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

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

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

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

宏和函数的一个对比：

命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。 那我们平时的一个习惯是：

把宏名全部大写

函数名不要全部大写

 #undef

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

如何使用呢？

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

 实例：

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

int main()
{
	int a = 0;
	int b = 1;
#undef MAX
	int c = MAX(a, b);
	printf("%d", c);
	return 0;
}

 这样代码再次运行时，就会报错，MAX未定义（要在MAX使用前）。

 命令行定义

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

#include <stdio.h>
int main()
{
int array [SIZE];
int i = 0;
for(i = 0; i< SIZE; i ++)
{
array[i] = i;
}
for(i = 0; i< SIZE; i ++)
{
printf("%d " ,array[i]);
}
printf("\n" );
return 0;
}

 编译指令：

 gcc -D SIZE=10 programe.c

 在输入编译指令时赋值也是可以的。

条件编译 

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

比如说：

调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

 常见的条件编译指令：

#if 常量表达式
//……
#endif

怎么使用呢？

举个例子：

int main()
{
#if 1
	printf("Hello world!\n");
#endif

	return 0;
}

 当我们想控制某个语句执行时，#if后边为真则执行，如果为假则不执行。感觉是不是很像if语句。

但与if语句不同的是，在预处理阶段，如果#if为假，那该语句在程序运行时就会被剔除。

 当然它也是可以进行嵌套使用的：

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

 不运行的代码，在预处理阶段就会被剔除，如下图：

 除此之外，它还能判断是否被定义

#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

#ifdef是判断某个标识符是否已经被定义，而#ifndef是判断某个标识符是否未被定义。 

 这样预处理指令是支持嵌套指令的例如：

#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

 最后一个#endif用于结束#elif defined(OS_MSDOS)和#elif defined(OS_MSDOS)

 文件包含

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

 头文件被包含的方式有两种：

• 本地文件包含
• 库文件包含

 本地文件包含，我们用的都是双引号，例如：

#include "filename"

 库文件包含：

#include <filename.h>

 这两种引用方式有什么不同呢？

两种方式确实有所不同，它们查找策略不同。

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

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

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

但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件

 嵌套文件包含

这些文件的包含其实还可以进行嵌套，在实际场景中经常遇到，例如我们在写一个扫雷小游戏时：

我们分了3个文件去写，一个.h文件用于声明，包含所有需要使用的头文件，而其他两个.c文件就可以直接包含我们自己创建的.h文件,如下图：

 当然这样嵌套的包含也存在弊端：

文件多次被包含，这样会有什么影响呢？

我们知道在预处理阶段，计算机就会将头文件中的所有内容写到代码中，如果头文件的内容很多，那么重复的包含就会导致预处理时多次将头文件内容加入到代码中，导致代码量加大。效率就会降低。

如何解决这个问题？ 答案：条件编译。

 每个头文件的开头这样写：

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

如果没有定义过test.h这个文件，就执行下边代码，如果定义过就不会再执行，重复包含。

 或者：

#pragma once

 在头文件的开头这样写，也是可以让头文件仅包含一次。

 这两种方式都可以避免头文件的重复引入。

 注： 推荐《高质量C/C++编程指南》中附录的考试试卷（很重要）。 笔试题：

1.  头文件中的 ifndef/define/endif是干什么用的?
2.  #include <filename.h> 和 #include "filename.h"有什么区别?

除此之外还有很多的预处理指令，这里就不再向大家一一介绍。

总结

希望本文能够为您提供有价值的学习资源，并帮助您更好地理解程序环境和预处理的重要性和作用。最后，感谢您的阅读！

到了这里，关于程序员进阶之路：程序环境和预处理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！