程序环境和预处理

Posted 跳动的bit

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了程序环境和预处理相关的知识，希望对你有一定的参考价值。

文章目录

前言

C语言的内容到这里就基本写完了，之前我们在写完代码时都是直接在VS中点"调试- >开始执行"，或者快捷键来运行我们的代码，接着代码的运行结果就咔咔的跑出来了。你是否有思考过一个写好的.c文件是如何变成.exe文件的呢 ？

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

在ANSIC的任何一种实现中，存在两个不同的环境
 
1️⃣ 翻译环境，在这个环境中源代码被转换为可执行的机器指令
 
2️⃣ 执行环境，它用于实际执行代码

💦 翻译环境（编译+链接）

❓❔ 细谈在.c变成.exe的过程中发生了什么


1️⃣ 组成一个程序的每个源文件通过编译过程分别转换成目标代码( object code )。

2️⃣ 每个目标文件由链接器( linker )捆绑在一起，形成一个单一而完整的可执行程序。

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

🎗编译又分为了预处理、编译、汇编

使用windows逐步编译.c文件最后生成.exe文件。注：提前配置好了gcc环境


当然要看细节还得是Linux

1️⃣ 预处理 gcc -E Add.c -> Add.i：
▶ 完成了头文件的包含 (对比stdio.h文件)
▶ #define定义的符号和宏的替换
▶ 注释删除

2️⃣ 编译 gcc -S Add.c -> Add.s：把C语言代码转换为汇编代码
▶ 语法分析
▶ 记法分析
▶ 语义分析
▶ 符号汇总：只会汇总一些全局的符号

3️⃣ 汇编 gcc -c Add.c -> Add.o：将汇编代码生成目标文件(二进制文件或机器指令)，elf格式。以下我们使用readelf工具来查看文件信息
▶ 生成符号表

🎗接着我们把Add函数单独拆开来看


4️⃣ 链接
▶ 合并段表
生成的.o文件是elf格式的，这种elf格式是由一些段组成的，最终要把这些目标文件链接生成一个可执行程序a.out，但巧的是这个可执行程序的格式也是elf格式
▶ 符号表的合并和符号表的重定位

vim练级攻略
vim速查卡

💦 运行环境

程序执行的过程中：
1️⃣ 程序必须载入内存中。在有操作系统的环境下，一般由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成

2️⃣ 程序执行开始，接着便调用main函数

3️⃣ 开始执行程序代码，这时程序将使用一个运行时堆栈 (stack)，堆栈指的是栈，存储函数的局部变量和返回地址。程序同时也可以使用静态 (static) 内存，存储于静态内存中的变量在程序的整个执行过程一直保留它们的值

4️⃣ 终止程序，正常终止main函数；也可能是意外终止

二、预处理详解

💦 预定义符号

> __FILE__     //进行编译的源文件
> __LINE__     //文件当前的行号
> __DATE__     //文件被编译的日期
> __TIME__     //文件被编译的时间
> __STDC__     //如果编译器遵循ANSI C，其值为1，否则未定义 (已测：VS2017中不支持，Linux支持)
> __FUNCTION__ //文件被编译的函数

❓❔ 这些预定义符号有什么用呢

当程序跑起来时，我们可能需要记录一些日志信息

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	FILE* pf = fopen("log.txt", "a+");
	if(pf == NULL)
	{
		perror("fopen");
		return 1;	
	}
	int i = 0;
	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;
}

💨 结果

💦 #define定义标识符

#define name stuff
name将会替换掉stuff

#define M 100
#define reg register//定义的也可以不是数字
#define do_forever for(;;)//也可以是一条语句 - 死循环
#define CASE break;case//一些奇怪的骚操作
int main()
{
	int N = M;
	reg int num = 0;//为register这个关键字，创建一个简短的名字
	do_forever;

	int n = 0;
	switch(n)
	{
	case 1:
	CASE 2://同break;case 2
	CASE 3:
	}
	return 0;
}

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

#define q 100; //语法支持但没必要，且有些场景可能会出错
#define M 1000; //场景
int main()
{
	int p = q;//同int p = 100;;

	//错误场景：
	int a = 10;
	int b = 0;
	if(a > 10)
		b = M;
		//; - err
	else  
		b = -M;
		
	return 0;
}

💦 #define定义宏

#define机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏 (macro) 或定义宏 (define macro)
宏的申明方式：
#define name(parament-list) stuff
其中的parament-list是一个由逗号隔开的符号表，它们可能出现在stuff
注意：
参数列表的左特号必须与name相邻
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分

#define SQUARE(X) X*X
#define SQUARE1(X) ((X)*(X))//括号很重要
#define DOUBLE(X) (X)+(X)
#define DOUBLE1(X) ((X)+(X))//有了括号也可能错
//#define SQUARE (X) X*X //err
#include<stdio.h>
int main()
{
	printf("%d\\n", SQUARE(3));//9，同SQUARE(3 * 3)
	/*------------------分割-------------------*/
	printf("%d\\n", SQUARE(3+1));//7，同3 + 1 * 3 + 1
	//如果想要达到16的效果：
	printf("%d\\n", SQUARE((3 + 1)));//16，(3 + 1) * (3 + 1)
	printf("%d\\n", SQUARE1(3+1));//16，同((3 + 1) * (3 + 1))
	/*------------------分割-------------------*/
	printf("%d\\n", 10 * DOUBLE(4));//44，同10 * (4) + (4)
	//如果想达到80的效果
	printf("%d\\n", 10 * DOUBLE1(4));//80，同10 * ((4) + (4))
	
	return 0;
}

💦 #define替换规则

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

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

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

3️⃣ 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就要重复上述过程
注意：
▶ 宏参数和#define定义中可以出现其它#define定义的常量。但是对于宏，不能出现递归，因为宏只做简单的文本替换，且只替换一次
▶ 当预处理器搜索#define定义的符号时，字符串常量的内容并不被搜索

#define M 100
#define MAX(X, Y) ((X)>(Y)?(X):(Y))

#include<stdio.h>
int main()
{
	int max = MAX(101, M);//1.M优先被替换
	//2.int max = MAX(101, 100)
	/*------------------分割-----------------*/
	printf("M = %d\\n", M);//3.字符串里的M不会被替换
	return 0;
}

💦 #和## (奇怪的用法 ）

#include<stdio.h>
void print(int x)
{
	printf("the value of a is %d\\n", x);
}
int main()
{
	int a = 10;
	print(a);
	//the value of a is 10
	int b = 20;
	print(b);
	//the value of b is 20
	int c = 30;
	print(c);
	//the value of c is 30
	return 0;
}

💨 结果

🎗 假设有以上这个场景，会发现print函数做不到，已经写死了，在#亮相前我们先来看一段代码

#include<stdio.h>
int main()
{
	//printf("hello"b"it\\n");//err
	printf("hello""bit\\n");//hello bit - 我们发现字符串是有自动连接的特点的
	return 0;
}


#define PRINT(X) printf("the value of "#X" is %d\\n", X)
#include<stdio.h>
int main()
{
	int a = 10;
	PRINT(a);//同printf("the value of ""a"" is %d\\n", a);。显然这里#的作用就是把参数变成字符串
	//the value of a is 10
	int b = 20;
	PRINT(b);
	//the value of b is 20
	int c = 30;
	PRINT(c);
	//the value of c is 30

	return 0;
}

💨 结果

🎗 以上代码代码虽然已经实现了print函数实现不了的功能，但是还有待改善 (当这里float f = 5.5f时就做不到了)

#define PRINT(X, FORMAT) printf("the value of "#X" is "FORMAT"\\n", X)
#include<stdio.h>
int main()
{
	int a = 10;
	PRINT(a, "%d");//同print("the value of ""a"" is ""%d""\\n", a);

	int b = 20;
	PRINT(b, "%d");

	int c = 30;
	PRINT(c, "%d");
	
	float f = 5.5f;
	PRINT(f, "%f");//同print("the value of ""f"" is ""%f""\\n", f);
	//the valu of f = 5.5
	return 0;
}

💨 结果

#define C1(X,Y) X##Y
#define C2(X,Y,Z) X##Y##Z
#include<stdio.h>
int main()
{
	int class101 = 100;
	printf("%d\\n", C1(class, 101));//100，同printf("%d\\n", class##101);通过观察结果我们发现##的作用是合并符号 -> printf("%d\\n", class101);

	//也可以合并多个符号
	int class2021101 = 100;
	printf("%d\\n", C2(class, 2021, 101));//同printf("%d\\n", class2021101);
	return 0;
}

💨 结果

💦 带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果，副作用就是表达式求值的时候出现的永久性的效果
🎗 先来看一种代码
int a = 1;
int b = a + 1; // b = 2, a = 1
int b = ++a; //b = 2, a = 2 -> 这里就说++a是有副作用的

#define MAX(X,Y) ((X)>(Y)?(X):(Y))
#include<stdio.h>

int main()
{
	int a = 5;
	int b = 8;
	int m = MAX(a++, b++);//同((a++)>(b++)?(a++):(b++));
	printf("m = %d\\n", m);//9
	printf("a = %d b = %d\\n", a, b);//6, 10
	return 0;
}

💨 结果

💦 宏和函数的对比

➰ 求较大值

#define MAX(X,Y) ((X)>(Y)?(X):(Y))
int max(int x, int y)
{
	return x > y ? x : y;
}
int main()
{
	int a = 5;
	int b = 8;
	return 0;
}

这里在求较大值时，宏是有自己的优势的，原因有二：

1️⃣ 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。

2️⃣ 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

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

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

2️⃣ 宏是没法调试的

3️⃣ 宏由于类型无关，也不够严谨

4️⃣ 宏可能会带来运算符优先级的问题，导致程序容易出错

🎗这里再来举一个宏能做到但是函数做不到的例子

#define MALLOC(n, type) (type*)malloc(n * sizeof(type))
int main()
{
	//malloc(10 * sizeof(int));
	//malloc(10, int);//上面那样写太麻烦了，想这样写
	
	MALLOC(10, int);//同(int*)malloc(10 * sizeof(int));
	return 0;
}

➰这里罗列一个宏和函数的对比表

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

🎗命名约定

一般来讲函数和宏的使得语法很相似。所以语言本身没帮我们区分二者，我们平时的一个习惯是：
▶ 把宏名全部大写
▶ 函数名不要全部大写

💦 #undef

用于移除一个宏定义

#define M 100
int main()
{
	int a = M;
#undef M
	printf("%d\\n", M);//err：未定义标识符
	return 0;
}

💦 命令行定义

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

🎗 以下将使用Linux来演示

此时我们使用命令行去定义m

💦 条件编译

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

🎗 常见的条件编译指令

/*
1.
#if 常量表达式 (如果为真则编译，否则不编译)
	//...
#endif
*/
int main01()
{
#if 1 
	printf("hehe\\n");
#endif
	return 0;
}
/*
2.
#if 常量表达式
	//...
#elif 常量表达式
	//...
#else
	//...
#endif
*/
int main02()
{
#if 1==1
	printf("hehe\\n");
#elif 1==2
	printf("haha\\n");
#else 
	printf("heihei\\n");
#endif
	return 0;
}
/*
3.
3.1
#define name1
int main()
{
#ifdef name1 //如果name1被定义，下面的语句则参与编译
	//...
#endif
	return 0;
}
3.2
#define name2
int main()
{
#if defined(name2)//如果name2被定义，下面的语句则参与编译
	//...
#endif
	return 0;
}
*/
#define TEST
int main03()
{
#ifdef TEST
	prinntf("test\\n");
#endif
	return 0;
}
/*
4.
4.1
int main()
{
#ifndef name1 //如果name1未定义，下面的语句则参与编译
	//...
#endif
	return 0;
}
4.2
int main()
{
#if !defined(name2)//如果name2未定义，下面的语句则参与编译
	//...
#endif
	return 0;
}
*/
int main04()
{
#ifndef HEHE
	printf("hehe\\n");
#endif
	return 0;
}
/*
5.嵌套指令
#if define(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 指令可以使另外一个文件被编译。就像它实际出现于#inc1ude 指令的地方一样。我们已经知道，#include 指令可以使另外一个文件被编译。就像它实际出现于#inc1ude 指令的地方一样。
这种替换的方式很简单︰预处理器先删除这条指令，并用包含文件的内容替换。这样一个源文件被包含10次，那就实际被编译10次。

🎗 头文件被包含的方式

< >和" "包含头文件的本质区别是：查找策略的区别

1️⃣ " “先在源文件所在的目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件，如果找不到就提示编译错误 (所以” "也可以包含库文件，但是没必要 )

2️⃣ < >直接去库目录下查找

🎗 文件的重复包含

当我们的一个项目中需要写很多文件时，这时可能会造成文件的重复包含，如果是stdio.h这样的几百行的头文件那么所占的空间将会更大，我们如何防止这种场景呢



以上是关于程序环境和预处理的主要内容，如果未能解决你的问题，请参考以下文章

译文：18个实用的JavaScript代码片段，助你快速处理日常编程任务

在 Android 中使用片段时处理后按

python+spark程序代码片段

是否有在单个活动中处理多个片段的 Android 设计模式？

代码片段 - Golang 实现简单的 Web 服务器

你如何在 python 中处理 graphql 查询和片段？