程序编译和链接的过程/预处理符号和用法【C语言】-阿里云开发者社区

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

标准规定C程序中需要有两种环境

翻译环境：源代码被转换为可执行的机器指令的环境
执行环境：用于执行代码的环境

2. 编译与链接

注：

.c后缀的文件称为源文件，需要编译

.h后缀的文件不需要编译

2.1 翻译环境

每个源文件(.c)都需要经过编译器单独处理，生成目标文件(.obj)。目标文件再与链接库结合，由编译器处理，生成可执行程序(.exe)

组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。

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

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

2.2 编译的三个阶段

2.2.1 预编译(.i)

包含头文件(#include)
删除注释
符号和宏(#define)的替换

可见，预编译（预处理）的阶段是对代码文本的操作

2.2.2 编译(.s)

将C语言代码翻译为汇编代码

词法分析：将一长串的代码分割为若干部分，让编译器知道哪里是循环，哪里是main函数等
语法分析：将若干部分串回来，让编译器判断代码是否符合规定的法则
语义分析：在将代码翻译为汇编代码之前，也要让编译器知道代码是怎么做的(它不能判断其是否符合逻辑)
*符号汇总：

2.2.3 汇编(.o)

将编译产生的汇编代码翻译为机器能直接接收的二进制指令(机器指令)
生成符号表：将函数的地址和名字记录，形成表

2.3 链接

合并段表
符号表的合并与重定位
如上述的add函数，合并段表以后就有两个add的地址，编译器取有效的地址作为add函数的地址

2.4 运行环境

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

3. 预处理

3.1 预定义符号

部分语言内置的预定义符号

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

例子

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

3.2 #define

3.2.1 #define 定义标识符

#define name stuff

例子

#define MAX 1000
//不要加分号

// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，
//每行的后面都加一个反斜杠(续行符)
//但不能加空格
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
date:%s\ttime:%s\n" ,\
__FILE__,__LINE__ , \
__DATE__,__TIME__ )

仅示例，以下这三种写法是不被大多数人接受的，因为实际中代码不是为了自己而写

#define reg register //为 register这个关键字，创建一个简短的名字
register int num1 = 0;
reg int mun2 = 0;
//两种定义方式等价

#define CASE break;case //在写case语句的时候自动把 break写上。

#define do_forever for(;;) //用更形象的符号来替换一种功能

3.2.2#define定义宏

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

宏（define macro）。

声明

#define name( parament-list ) stuff

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

注意：

参数列表的左括号必须与name紧邻。

如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

例

#include<stdio.h>
#define SQUARE(x) x*x
int main()
{
  int a = 5;
  printf("%d\n", SQUARE(a));
  return 0;
}

结果为25

把printf("%d\n", SQUARE(a));改为printf("%d\n", SQUARE(a+1));

结果会是36吗？

答案是11= 1 + 5 * 1 + 5

通过这个例子可以体会到宏仅仅是替换，而不是像函数那样传参

我们期望结果是36，但因为操作符优先级，导致了结果错误。所以为了达到期望的结果，我们可以使用括号

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

(1 + 5) * (1 + 5) = 36

仅仅这样够吗？

例

#include<stdio.h>
#define DOUBLE(x) (x)+(x)
int main()
{
  int a = 5;
  int ret = 10 * DOUBLE(a);
  printf("%d\n", ret);
  return 0;
}

以上面的思路，结果不是10 * 10 = 100，而是10 * 5 + 5 = 55

所以为了完全规避错误，应该再加一层括号

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

3.2.3 #define 替换规则

在程序中扩展#define定义符号和宏时，分为以下几个步骤。

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

注意：

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

#define MAX = 1000
#include<stdio.h>
int main()
{
  int a MAX;
  printf("MAX = %d", a);
  //如这里的常量字符串中的MAX是不会被扫描的
  return 0;
}

3.2.4 #和##

任何将参数插入字符串中？

例

void print(int a)
{
  printf("a的值为%d\n", a);
}
#include<stdio.h>
int main()
{
  int a = 10;
  int b = 20;
  print(a);
  print(b);
  return 0;
}

以上代码希望每次打印出来的语句x的值是与x对应的，但这种效果函数无法做到

再来看一例代码

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

在使用打印函数时，将字符串拆开后打印的效果是一样的，因为该函数会将各部分的字符串连接成一个字符串来打印。

启发：

如果将上述的x变成一个“x”常量字符串插入要打印的语句中，那么打印出来的结果就会随x的变化而变化

下面介绍#在此处的用法

#include<stdio.h>
#define PRINT(x) printf(#x"的值为%d\n", x);
int main()
{
  int a = 10;
  int b = 20;
  PRINT(a);
  PRINT(b);
  return 0;
}

##可以把位于它两边的符号合成一个符号。

它允许宏定义从分离的文本片段创建标识符。

用例

#include<stdio.h>
#define F(x, y) x##y
int main()
{
  int xy = 88;
  printf("%d\n", F(x, y));
  return 0;
}

3.2.5 部分宏参数的副作用

引例

x = x + 1;
x++;

前者未改变x本身的值，无副作用

后者改变了x本身的值，有副作用

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

例

#define MAX(X, Y) ((X)>(Y)?(X):(Y))
#include<stdio.h>
int main()
{
  int a = 10;
  int b = 11;
  int c = MAX(a++, b++);
  printf("%d\n", a);
  printf("%d\n", b);
  printf("%d\n", c);
  return 0;
}

分析

前面已经强调，宏在编译阶段是直接将#define定义的符号替换，而不是向函数那样传参

对于int c = MAX(a++, b++); 和#define MAX(X, Y) ((X)>(Y)?(X):(Y))

在编译阶段实际上代码已经是

int c = ( (a++)>(b++)?(a++):(b++) );

b实际上自增了两次

像这样带有副作用的宏，实际中谨慎使用

3.2.6 宏和函数对比

就上面的比较大小的功能，使用宏还是使用函数实现，哪个更好？

答案是宏，为什么？

#define MAX(X, Y) ((X)>(Y)?(X):(Y))
#include<stdio.h>
int Max(int x, int y)
{
  return x > y ? x : y;
}
int main()
{
  int a = 10;
  int b = 11;
  int ret1 = MAX(a, b);
  int ret2 = Max(a, b);
  printf("%d\n", ret1);
  printf("%d\n", ret2);
  return 0;
}

计算机的处理速度很快，我们无法体会到它们的差异

首先回想之前的知识：函数需要接收参数，也要返回参数，在调用函数之前需要做准备工作；宏仅仅是替换。

让我们大概看一下汇编代码，只需体会它们在数量上的差别即可

Max函数的汇编代码

MAX宏的汇编代码

单从汇编代码的数量上我们可以直观的感受到两者的差别。

为什么不用函数来完成这个任务？

宏比函数在程序的规模和速度方面更胜一筹，因为宏不需要像函数那样在调用前和调用完毕后进行的一系列工作，省去了函数调用和返回的开销，直接替换宏定义的符号
更为重要的是函数的参数必须声明为特定的类型。所以函数只能在特定类型的表达式上使用，如上例只能比较int型的数据。然而宏可适用于任何可比较的数据类型。所以宏是和数据类型无关的，它做的事只有一个——替换。

一个例子体会宏的妙处

//malloc的使用有时会让人感觉有点麻烦
//用宏定义该函数，只需传数量和类型即可
#define MALLOC(num, type) ( type *)malloc(num * sizeof(type) )
MALLOC(10, int);//类型作为参数
//等价于(被替换后)
(int *)malloc(10 * sizeof(int));

宏并不是完美的

每次使用宏的时候，将宏定义的符号替换，然后插入到代码中。除非宏比较短，否则可能大幅度增加程序的长度。

#define ADD(X, Y) ((X)+(Y))
#include<stdio.h>
int main()
{
  int a = 1;
  int b = 2;
  int c = 1;
  int d = 2; 
  int e = 1;
  int f = 2; 
  //......
  ADD(a, b);
  ADD(c, d);
  ADD(e, f);
  //......
  return 0;
}
//在编译时，ADD被替换以后，这些代码会变得很多
//如果是函数，仅仅返回的是一个值，相比之下函数更简洁

宏本身产生的错误是不能通过调试发现的
宏定义的符号在编译时已经被替换，而我们调试的代码是生成.exe以后的代码，这时我们眼前的宏定义的符号在计算机看来符号已经不是它了，而是符号对应的宏
宏与类型无关，虽然它很妙，但使用起来不够严谨
宏可能会带来运算符优先级的问题，导致程容易出现错，就如前面的例子(a++)提到的那样

注：

约定：宏名全部大写；函数名部分大写或不大写

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

在Lunix环境下的编译指令

gcc -D ARRAY_SIZE=10 programe.c
//programe是当前源文件的文件名
//gcc - 编译
// -D - 定义(define)

当按下回车，编译器便能进行编译，生成.exe文件

3.5 条件编译

在日常初学编程时，我们通常要对不同的代码分别编译，这时我们的习惯是将某部分代码注释掉，以便它们不被编译。但实际上，这样做不适合工程量很大的实际项目，我们需要有个像条件开关(switch)一样的工具，控制某些语句在某些条件下是否被编译。

编译指令1

#if 常量表达式
//...
#endif
//常量表达式由预处理器求值。

例

#include<stdio.h>
int main()
{
#if 0//常量表达式的值为真即可
  printf("1 ");
#endif
  printf("2 ");
  return 0;
}

结果：1 2

如果将#if 1 == 1改为#if 0 呢？

编译指令2：多个分支的条件编译

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

例

#include<stdio.h>
int main()
{
#if 1 == 1
  printf("1 ");
#elif 2 == 1//elif是else if的简写
  printf("3 ");
#endif
  printf("2 ");
  return 0;
}

结果：1 2

编译指令3：判断是否被定义

//两种写法等价
#if defined(symbol)
#ifdef symbol
//两种写法等价
#if !defined(symbol)
#ifndef symbol
//两者互为否定

例

#include<stdio.h>
#define DEBUG1 0//这里的常量存在与否，不论何值都没关系
//只要有定义即可
int main()
{
#ifdef DEBUG1
  printf("DEBUG ");
#endif 
#ifndef DEBUG2
  printf("NOT DEBUG2");
#endif
  return 0;
}

注：#ifndef 的n是not的意思

结果为DEBUG NOT DEBUG2

第一部分：因为DEBUG1有定义，所以#ifdef DEBUG1值为真，打印

第二部分：因为DEBUG2未定义，所以#ifndef DEBUG2值为真，打印

编译指令4：嵌套指令

#if defined(A)
    #ifdef OPTION1
      a_option1();
    #endif
      #ifdef OPTION2
        a_option2();
      #endif
#elif defined(B)
    #ifdef OPTION2
        b_option1();
    #endif
#endif

用缩进表示了各个嵌套的配对情况

小结

实际上，条件编译是被广泛应用的，比如这里随意打开一个编译器给出的头文件源代码

所以这个知识点蛮重要的

3.6 文件包含

在编译的第一个阶段预编译中，头文件被包含在当前源代码文件中(.c)，是如何被包含的呢？

例如#include<stdio.h>这条语句，在编译时预处理器删除这条指令，如何将该头文件(.h)的内容替换至该位置，其实是有几百行的。

而每增加一条包含头文件的语句，都会将内容复制一次。

3.6.1 头文件被包含的方式

库文件包含

#include <filename.h>

本地文件包含

#include "filename"

查找流程：

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

由此看来用双引号包含头文件似乎是万能的方式，但这么做会影响效率。

举个栗子，假设一个工程要使用到很多个人做的函数，它们本身就已经包含了不少头文件，再加上自己引用的头文件，实际上已经包含了很多次头文件了，这就得让机器多找很多次头文件，影响效率。

所以两种引用头文件的方式要区分开，形成习惯。

那有没有什么方法解决这个问题呢？且看~

3.6.2 嵌套文件包含

像出现以上这种嵌套文件包含的情况，我们可以使用条件编译提高包含的效率，减少头文件包含的次数

每个头文件的开头写：

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

这是一种久远的写法

或：

#pragma once

这是一种较新的写法，一些老旧的编译器无法通过编译

比如stdio.h的源代码在开头就这么写了

4. 一道笔试题

这是某年百度公司招聘系统工程师的笔试题

请编写宏，计算结构体中某变量相对于首地址的偏移，并给出说明

分析：这其实是让我们模拟实现offsetof函数，首先请回顾该函数的用法

#include<stdio.h>
#include<stddef.h>
struct Stu
{
  char name[20];
  int age;
  char adrs[20];
};
int main()
{
  int ret = offsetof(struct Stu, age);
  printf("%d\n", ret);
  return 0;
}

传入参数为结构体名和成员名

在模拟实现之前，要明确一点：某位置的偏移量是由该位置的地址与起始位置做差得到的，然而在宏定义中，我们无法得知它们的地址，因为我们都没有使用它，自然找不到成员的地址。

offsteof函数本身用了一种巧妙的方法：将0作为结构体的起始地址，成员变量的地址即为偏移量

即将0这个数字强转为结构体指针类型，这时就可以认为在0地址处创建了一个结构体，然后访问成员变量(此时类型是成员变量的类型)，接着取其地址(因为偏移量是地址之差)，再强转为int或size_t(unsignud

int)类型

#include<stdio.h>
#define OFFSETOF(struct_name, member_name) (int)(&(((struct_name*)0)->member_name))
struct Stu
{
  char name[20];
  int age;
  char adrs[20];
};
int main()
{
  int ret = OFFSETOF(struct Stu, age);
  printf("%d\n", ret);
  return 0;
}

结果：20

4/5/2022

Man9o

欢迎指正！

程序编译和链接的过程/预处理符号和用法【C语言】

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

2. 编译与链接

2.1 翻译环境

2.2 编译的三个阶段

2.2.1 预编译(.i)

2.2.2 编译(.s)

2.2.3 汇编(.o)

2.3 链接

2.4 运行环境

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.2.6 宏和函数对比

3.3 #undef

3.4 命令行定义

3.5 条件编译

3.6 文件包含

3.6.1 头文件被包含的方式

3.6.2 嵌套文件包含

4. 一道笔试题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

程序编译和链接的过程/预处理符号和用法【C语言】

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

2. 编译与链接

2.1 翻译环境

2.2 编译的三个阶段

2.2.1 预编译(.i)

2.2.2 编译(.s)

2.2.3 汇编(.o)

2.3 链接

2.4 运行环境

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.2.6 宏和函数对比

3.3 #undef

3.4 命令行定义

3.5 条件编译

3.6 文件包含

3.6.1 头文件被包含的方式

3.6.2 嵌套文件包含

4. 一道笔试题

热门文章

最新文章

相关课程

相关电子书

相关实验场景