【Linux】程序的编译

今天我们来介绍一下程序的编译过程 以及 一些相关的知识

目录

1. 程序环境

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

其中翻译环境可以分为 编译过程 和 链接过程。 编译可以分为 预处理，编译 ，汇编过程。接下来我们会对每一步进行比较详细的介绍。
在这里插入图片描述

2. 编译与链接

我们先创建一个文件test.c:
在这里插入图片描述

2.1 编译

2.2.1 预编译（预处理）

gcc test.c -E > test.i

我们可以打开test.i来看一下，我们发现多出了许多内容，这是为什么？

其中有两部分比较值得我们注意：
在这里插入图片描述

在预处理阶段：

  1. 完成了头文件的包含
  2. #define 定义的符号和宏会被替换
  3. 删除注释

2.2.2 编译

当我们完成了预处理，我们开始编译

gcc test.i -S

在这里插入图片描述
此时编译器把C语言转化为了汇编代码。
其中包含了 语法分析，词法分析，语义分析，符号汇总

汇编本身就是一门学科，所以这里只作简单了解。

2.2.3 汇编

gcc test.s -c

在经过汇编之后，会产生一个文件 test.o (windows下叫做test.obj)，该文件也叫做 目标文件。
在这里插入图片描述
我们发现，这明显是一个 二进制文件，该文件是 elf 格式的，可以简单理解为按段存储。
也就是说，汇编 是把 汇编代码转化为二进制指令（机器指令）

对于这种文件，我们可以通过 readelf 工具来转换成我们可以看懂的格式：
在这里插入图片描述

我们发现一些可以看懂的符号，test.c ,g_val,Add,main,printf ，我们发现这些符号都具有全局属性。

为了更好解释这个问题，我重新写了两个例子：
在这里插入图片描述
我们现在有test.cpp,add.cpp,它们分别在编译阶段进行了符号汇总（只汇总全局符号），然后在汇编阶段生成 符号表。
在这里插入图片描述
在这里插入图片描述

2.2 链接

当我们完成了汇编，连接就可以把多个目标文件和链接库进行链接：

  1. 合并段表
  2. 合并与重定位符号表

链接后得到的可执行文件的格式也是 elf 格式的。

我们通过符号表的合并与重定位就可以找到来自其他文件的函数或者变量。
在这里插入图片描述

我们可以将整个翻译过程 总结如下过程：
在这里插入图片描述

3. 预处理

3.1 预定义符号

C语言中村子许多内置的预定义符号

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

这些符号在我们编写日志信息的时候很好用，可以帮助我们定位文件，行号，时间等等。

3.2 #define

3.2.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__ ) 
int main
{
	reg int num=10;
	do_forever;
	DEBUG_PRINT;
}

当我们在define 定义标识符的时候，不建议加上";"
比如，下面的场景下就会导致语法错误：

#define MAX 1000;

int main()
{
	if(condition)
		max = MAX;
	else
		max = 0;
}

3.2.2 #define 定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff

其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。
注意：

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

假设现在我们想定义一个实现乘法的宏：

#define SQUARE( x ) x * x

int main()
{
	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)

同样，我们定义一个加法宏：

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

这样也不是正确的，应该改成：

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

3.2.3 #define 替换规则

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

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

这里需要注意：

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

#define M 100
#define SQUARE(X) ((X)*(X))
#define DOUBLE(X) ((SQUARE(X))+(SQUARE(X)))  //可以调用其他宏
//#define DOUBLE(X) ((DOUBLE(X))+(DOUBLE(X)))  不能递归调用
//括号很重要
int main()
{
	printf("%d\n", SQUARE(3+1));
	printf("%d\n", 10 * DOUBLE(4));

	printf("M = %d\n", M); //字符串常量的M并不被搜索替换
	return 0;
	
}

3.2.4 # 与 ##

  • #
    此时有一个场景，我们想把参数插入到字符串中，有扫描方法？

我们可以这样写：

#define PRINT(FORMAT, VALUE) printf("the value is "FORMAT"\n", VALUE);
...
PRINT("%d", 10);

但是，这样写存在明显的局限性，只有当字符串作为宏参数的时候才可以直接把字符串放在字符串中。

这时候我们可以使用 “#”,把一个宏参数变成对应的字符串：

#define PRINT(X,FORMAT) printf("the value of "#X"is " FORMAT"\n",X);
int main()
{
	//the value of a is 10
	int a = 10;
	PRINT(a, "%d");
	//the value of f is 5.5
	float f = 5.5f;
	PRINT(f, "%f");
	return 0;
}
  • ##

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

#define ADD_TO_SUM(num, value) \
sum##num += value;
...
int sum5=10;
ADD_TO_SUM(5, 10);//作用是：给sum5增加10.

3.2.5 宏参数的副作用

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

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

我们得到的结果是：

x=6 y=10 z=9

3.2.6 宏与函数的对比

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

#define MAX(a, b) ((a)>(b)?(a):(b))

相较于函数，宏有一些函数不可代替的优点:

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

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

但是，宏也也有一些缺点：

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

对于宏和函数，我们要因地制宜，权衡利弊，进行合理的选择。

3.2.7 关于宏的一些练习

  1. 写一个宏，可以将一个整数的二进制的奇数位和偶数位交换
#define SWAP(N) ((N&0xaaaaaaaa)>>1) + ((N&0x55555555)<<1)

我们以十进制数字 5为例子：

00000000 00000000 00000000 00000111
取出所有奇数位： 5& 01010101 01010101 01010101 01010101 (即0x55555555)
   得到： 00000000 00000000 00000000 00000101
   左移一位到偶数位：00000000 00000000 00000000 00001010
   
取出所有偶数位： 5& 10101010 10101010 10101010 10101010 (即0xaaaaaaaa)
   得到： 00000000 00000000 00000000 00000010
   右移一位到奇数位 00000000 00000000 00000000 00000001
   
相加： 00000000 00000000 00000000 00001011
  1. 写一个宏，计算结构体某变量相对于首地址的偏移，并给出说明

这其实是C语言中定义的宏 offsetof,它可以计算出结构体中的成员变量的偏移量。

#include<stddef.h>
struct A
{
	int a;
	short b;
	int c;
	char d;
};

int main()
{
	printf("%d\n",offsetof(struct A,a));//0
	printf("%d\n",offsetof(struct A,b));//4
	printf("%d\n",offsetof(struct A,c));//8
	printf("%d\n",offsetof(struct A,d));//12
	return 0;
}

那么我们应该如何自定义出一个相同功能的宏呢？

#define OFFSETOF(struct_name,mem_name) (int)&(((struct_name*)0)->mem_name)

对于这种写法，我们可以理解为在0地址处放了一个结构体（实际上没有开辟空间）。
我们同样可以改为：

#define OFFSETOF(struct_name,mem_name) (int)&(((struct_name*)0x40)->mem_name)-0x40

3.3 #undef

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

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

3.4 命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假
定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一
个机器内存大写，我们需要一个数组能够大写.）

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

我们可以使用命令行参数进行编译：

gcc -D ARRAY_SIZE=10 programe.c

3.5 条件编译

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

在这里插入图片描述

常见的条件编译指令

1.常量表达式

#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
  1. 多个分支的条件编译

在这里插入图片描述
3. 判断是否被定义

#if defined(symbol)
#ifdef symbol

#if !defined(symbol)
#ifndef symbol
  1. 嵌套指令
#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

3.6 文件包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方
一样。

这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。

3.6.1 头文件被包含的方式

  • 本地文件被包含的方式
#include "filename"

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

#include <filename.h>

查找策略：编译器查找库函数文件所在标准位置查找文件

  • Linux环境的标准头文件的路径
/usr/include

这样是不是可以说，对于库文件也可以使用 “” 的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了

3.6.2 嵌套文件包含

如何避免包含重复头文件呢？

有两种方式：

  • pragma once
  • 条件编译
#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif  //__TEST_H__

3.7 其他预处理命令

#error
#pragma
#line
...