程序编译与链接

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、程序的翻译环境与运行环境

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

1.详解翻译环境（编译与链接）

示例：在Linux环境中感受程序的编译与链接过程。

2. 程序的运行环境

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

二、预处理详解

1.预定义符号

__FILE__      //进行编译的源文件
__LINE__     //文件当前的行号
__DATE__    //文件被编译的日期
__TIME__    //文件被编译的时间
__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义

举个例子:

printf("file:%s line:%d\n", __FILE__, __LINE__);

2.#define

(1)#define 定义标识符

语法：
 #define name stuff 	//建议不要加上 ; ,这样容易导致问题

举个例子：

#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__ )     

(2)#define 定义宏

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

• #define name( parament-list ) stuff 其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。 注意： 参数列表的左括号必须与name紧邻。 如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。
• #define定义宏时，变量是直接替换的，并不会计算好后传递

举个例子：
请思考，如果这几个的代码能正常运行，打印的结果为多少？

//代码1
#define SQUARE( x ) x * x
int a = 5;
printf("%d\n" ,SQUARE( a ));

//代码2
#define SQUARE( x ) x * x
int a = 5;
printf("%d\n" ,SQUARE( ( a + 1) ));

//代码3
#define SQUARE( x ) x * x
int a = 5;
printf("%d\n" ,10 * SQUARE( ( a + 1) ));

根据上述第一点第二点分析：
对与代码1，直接替换，printf("%d\n" ,5 * 5);,结果为25
对与代码1，直接替换，printf("%d\n" ,5 + 1 * 5 + 1);,结果为11
对与代码1，直接替换，printf("%d\n" ,10 * 5 + 1 * 5 + 1);,结果为56

因此，我们在定义宏的时候，千万不要吝啬()，给每个表达式都打上(),
如：

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

注意：

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

3.#和##

(1)#
平时，我们写代码时可能会有一个疑问：如何把参数插入到字符串中
例如：

代码如下（示例）：

void print(int a)
{
	printf("the value of a is %d\n", a);//字符串内固定了是a
}

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

可以看到，无论我们是打印a还是打印b，字符串内打印的都是a，因为字符串内固定了是a。
要解决这个问题，先看这个代码：
首先我们看看这样的代码：

#include <stdio.h>
int main()
{
	printf("hello world\n");
	printf("hello " "world\n");
	printf("hel" "lo " "world\n");
	return 0；
}

程序运行可以发现打印结果都是hello world
我们发现字符串是有自动连接的特点的。

1. 那我们是不是可以写这样的代码？：

 void print(int a)
{
	printf("the value of "a" is %d\n", a);//字符串内固定了是a
}

另外一个技巧是： 使用 # ，把一个宏参数变成对应的字符串。

 void print(int a)
{
	printf("the value of "#" is %d\n", a);
}
#define PRINT(X) printf("the value of " #X " is %d\n", X)

这时就能就能达到把参数插入到字符串中的目的。
（2）##
##可以把位于它两边符号和成一个符号

例如：
int a = 0;
int b = 0;
a##b;//等价于标识符ab

三、宏和函数比较

• 宏相比函数有优势的地方

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

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

int main()
{
	int a = 10;
	int b = 20;
	float c = 3.0f;
	float d = 4.0f;
	//函数在调用的时候
	//会有函数调用和返回的开销
	//
	float max = Max2(c, d);
	printf("max = %d\n", max);
	//预处理阶段就完成了替换
	//没有函数的调用和返回的开销
	max = MAX(c, d);
	max = ((c) > (d) ? (c) : (d));
	printf("max = %d\n", max);
	/*int max = Max(a, b);
	printf("max = %d\n", max);
	max = MAX(a, b);
	printf("max = %d\n", max);*/

	return 0;
}

#define MALLOC(num, type) (type*)malloc(num*sizeof(type))
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	int* p = MALLOC(10, int);
	//int* p = (int*)malloc(10 * sizeof(int));
	return 0;
}

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

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

对于第四点，可以有这个示例：

#define MAX(X, Y)     ((X)>(Y)?(X):(Y))
int main()
{
	int a = 10;
	int b = 11;

	int max = MAX(a++, b++);
	//int max = ((a++) > (b++) ? (a++) : (b++));

	printf("%d\n", max);//12
	printf("%d\n", a);//11
	printf("%d\n", b);//13

	return 0;
}

这个函数在打印的同时改变了a，b的结果，而且打印结果不明。尽量不要写出这种代码，对于上述代码中的a，b传参可以写成a+1，b+1的形式。

四.命令行定义

举个例子：在Linux下运行

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

在上述代码中，ARRAY_SIZE是未定义的，在Linux下编译时，我们可以按下下述指令:
gcc -D ARRAY_SIZE=10 programe.c
这时编译器会直到将ARRAY_SIZE赋值成10；

五. 条件编译

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

#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__ 
 } 

常见的条件编译指令：
1. 
#if 常量表达式
 //... 
#endif 
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1 
#if __DEBUG__ 
 //.. 
#endif 
2.多个分支的条件编译
#if 常量表达式
 //... 
#elif 常量表达式
 //... 
#else 
 //... 
#endif 
3.判断是否被定义
#if defined(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 

六. 文件包含

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

• 本地文件包含

#include "filename"

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

• 库文件包含

#include <filename>

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

为了防止头文件重复被包含，可以使用条件编译
即在每个头文件的开头写：
#ifndef TEST_H
#define TEST_H
//头文件的内容
#endif //TEST_H
或者：
#pragma once

结语

到这里，C语言学习系列正式完结。这里，先感谢b站鹏哥C语言。如果小伙伴们感兴趣，也可以点击链接前往。