程序环境和预处理(代码片段)

跳动的bit 跳动的bit     2022-12-12     117

关键词:

前言

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这样的几百行的头文件那么所占的空间将会更大,我们如何防止这种场景呢



程序环境和预处理(代码片段)

...a6;翻译环境(编译+链接)💦运行环境二、预处理详解💦预定义符号💦#define定义标识符💦#define定义宏💦#define替换规则💦#和##(奇怪的用法)💦带副作用的宏参数 查看详情

程序环境和预处理(代码片段)

程序环境和预处理(二)一、预定义符号介绍预处理详解预定义符号例子:二、预处理指令#define#define#define定义标识符(#define是定义符号的)在编译常出现的几个列子思考:#define定义宏定义语法#define替换... 查看详情

c语言学习笔记(19)程序环境和预处理(代码片段)

...的翻译环境和执行环境翻译环境(编译+链接)预处理编译汇编运行环境预处理预定义符号#define#define定义标识符#define定义宏#define替换规则#和##带副作用的宏参数宏和函数的对比#undef命令行定义条件编译文件包含头文... 查看详情

程序由创建到得到运行结果的过程你知道吗?程序的环境和预处理爆肝总结画图详解(代码片段)

程序的环境和预处理文章目录程序的环境和预处理程序的翻译环境和执行环境编译+链接翻译环境编译也分为三个阶段预处理阶段编译阶段汇编阶段链接阶段运行环境(执行环境)预处理详解预定义符号#define#define定义标识符#defin... 查看详情

c语言进阶学习笔记——程序环境和预处理(代码片段)

...翻译环境和执行环境详解编译+链接翻译环境运行环境预处理详解预定义符号#define#define定义标识符#define定义宏#define替换规则#和##带副作用的宏参数宏和函数宏和函数的对比命名约定#undef命令行定义条件编译文件包含头文件被... 查看详情

程序环境和预处理(代码片段)

...a6;翻译环境(编译+链接)💦运行环境二、预处理详解💦预定义符号💦#define定义标识符💦#define定义宏💦#define替换规则💦#和##(奇怪的用法)💦带副作用的宏参数💦宏和函数的对比... 查看详情

长文详解程序运行是个怎样的环境?预处理阶段在做什么?程序中我们不知道的一些事~(代码片段)

程序环境和预处理老规矩笔记在gitee自取~:程序环境和预处理笔记❤️欢迎喜欢学习C/C++的朋友互关一起努力!!❤️文章目录程序环境和预处理一、程序的环境二、预处理符号三、预处理指令#define1.定义标识... 查看详情

预处理和程序环境(代码片段)

预处理和程序环境一、程序的翻译环境和执行环境二、详解编译+链接三、#define1.#define定义标识符2.#define定义宏3.#define的替换规则4.#和##4.1#的使用4.2##的使用四、宏和函数对比五、条件编译一、程序的翻译环境和执行环境我们... 查看详情

c语言编译过程,满满的干货!!!(代码片段)

程序环境和预处理一、程序翻译和运行环境二、预处理详解1.预定义符号2.define定义宏3.#和##的区别4.宏和函数好坏比较5.命名约定6.头文件中<>和""区别7.条件编译一、程序翻译和运行环境翻译环境:在翻译环境中ÿ... 查看详情

c语言中程序的编译(预处理操作)+链接详解(详细介绍程序预编译过程)(代码片段)

...目录1.前言2.翻译环境和运行环境2.1翻译环境2.2运行环境3.预处理详解3.1预定义符号3.2#define定义的标识符常量和宏3.2.1#define定义的标识符常量3.2.2#define定义的宏3.2.3#define替换规则3.2.4#和##3.2.5带副作用的宏参数3.3宏和函数的对比4.... 查看详情

c语言——程序环境和预处理

程序的翻译环境和执行环境编译+链接预处理一.程序的翻译环境和执行环境在ANSIC标准的任何一种实现中,存在两种不同的环境:翻译环境:该环境中源代码会被转换为可执行的机器指令 执行环境:其用于实际执行代码二.编... 查看详情

c语言-程序环境和预处理(代码片段)

文章目录预处理详解1.预定义符号2.#define2.1#define定义的标识符2.2#define定义宏2.3#define替换规则注意事项:2.4#和###的作用##的作用2.5带副作用的宏参数2.6宏和函数的对比宏的优势:宏的劣势:宏和函数的一个对比命名约... 查看详情

梦开始的地方——c语言预处理+编译过程(代码片段)

文章目录C语言程序的编译(预处理)1.编译和链接1)编译的几个阶段预编译阶段编译阶段汇编阶段2)链接2.预处理1)预定义符号2)#define3)#和##4)带副作用的宏参数5)宏和函数对比3.常见预处理命令1)#undef2)命令行定义3)条件编译4)文件包含5... 查看详情

程序的环境和预处理

1.程序的环境预编译1.头文件的包含2.#define的预处理指令的执行3.注释的删除编译汇编链接运行1.程序的环境写过无数代码的你是否想过你写的.c文件编译链接运行形成.exe文件的中间是怎样执行的吗?从.c文件到.exe文件到代码... 查看详情

c语言篇——程序的编译(代码片段)

...翻译环境和执行环境编译和链接翻译环境编译的几个阶段预处理编译汇编链接运行环境程序的翻译环境和执行环境在ANSIC的任何一种实现中,存在两个不同的环境:第1种是翻译环境,在这个环境中源代码被转换为可执行的... 查看详情

c语言篇——程序的编译(代码片段)

...翻译环境和执行环境编译和链接翻译环境编译的几个阶段预处理编译汇编链接运行环境程序的翻译环境和执行环境在ANSIC的任何一种实现中,存在两个不同的环境:第1种是翻译环境,在这个环境中源代码被转换为可执行的... 查看详情

c语言进阶学习笔记七程序执行+调试技巧(实用技巧篇)(代码片段)

文章目录一、程序执行篇①预处理详解②宏定义③define标识符字符串④define宏名(参数表)字符串⑤宏和函数对比二、调试技巧篇①什么是bug?②调试是什么?有多重要?③debug和release的介绍④windows环境调试介绍⑥如何写出... 查看详情

c语言预处理和程序环境

...译阶段 汇编阶段 链接阶段(不属于编译阶段)预处理详解预定义符号 #define#define定义标识符#define定义宏#define的替换规则 #和##的使用 带副作用的宏参数 宏和函数的对比一些命名的规则 #undef命令行的定义条件编译... 查看详情