【进阶C语言】编译与链接、预处理符号详解

代码是怎么变成可执行程序的？

一、翻译环境

    翻译环境是将.c文件翻译成.exe文件，而执行环境是将.exe文件执行成代码。翻译环境又分为编译和链接两部分。

我们假设当前撰写的文件为test.c文件

编译

编译整个过程完成的事情：生成可执行程序，依赖编译器，如VS2022

1.预编译（预处理）

预处理阶段也成为文本操作，也就是处理完成之后我们还可以看得懂的。

【这个步骤做的事情】

（1）test.c文件会被处理成test.i文件。

（2）注释会被替换成一个空格，可以理解成被删除了。

（3）头文件包含的文件会完整的展开到文件里面（#include<>包含的文件会消失）

（4）#define符号的替换

所有的预处理指令都会在预编译阶段被处理掉

2.编译

生成.s文件

把c语言代码生成汇编代码

【编译步骤会完成的事情】

（1）test.i文件会变成test.s文件（也就是生成test.s文件）

（2）把C语言代码翻译成汇编代码（肉眼看不懂）

生成汇编代码需要做的事情：

1.词法分析   2.语法分析    3.语义分析    4.符号汇总

3.汇编

把汇编代码生成了二进制的指令，生成.o的文件（目标文件）

生成符号表

【汇编操作会完成的事情】

（在linux环境下生成的目标文件是.o文件，在windows环境下生成的是.obj文件）

（1）test.s文件会变成test.o文件（也就是产生test.o文件--目标文件）

（2）把汇编代码翻译成了二进制的指令，也就是生成的test.o文件

（3）生成符号表（在链接的步骤产生作用）

一般是汇总全局范围内可以看到的符号，例如：main函数等，像局部变量这些不会汇总。

链接

【在链接过程会完成的事情】

test.o--->test

（1）链接目标文件（test.o文件）和链接库生成可执行程序（二进制的程序）

（2）合并段表

把目标文件里面相同段落的数据进行合并

（3）符号表的合成和重定位（在汇编阶段生成的符号表）

把每个目标文件里面的符号汇总在一起（并附带相关的地址）

二、运行环境

运行环境也叫执行环境，用来实际执行代码。

在运行环境会完成的步骤：

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

2. 程序的执行便开始。接着便调用main函数。

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

4. 终止程序。正常终止main函数；也有可能是意外终止。

三、预处理符号详解

前言：预处理指令就是在翻译环境-->编译-->预编译（预处理），这一步完成的。

1.预定义符号

（1）认识

预定义符号是C语言内置的一些符号，有以下符号：

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

符号的输入细节：前后分别是两个下划线_ _，连起来：__

（2）怎么使用

看一段代码：

#include<stdio.h>
int main()
{
  printf("%s\n", __FILE__);
  printf("%d\n", __LINE__);
  printf("%s\n", __DATE__);
  printf("%s\n", __TIME__);
  printf("%s\n", __FUNCTION__);//文件正在编译哪个函数
  return 0;
}

看一下运行结果：

解析：

（3）最后的符号

__STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义

说明当前的编译器为遵循ANSI C

2.#define

前言：该预处理指令的种类繁多

（1）#define定义标识符

【语法结构】

#define name stuff

标识符的内容是多组多样的，也就是将被替换的内容。

【使用例子1】定义标识符常量

#include<stdio.h>
#define MAX 100
#define M 3+5
int main()
{
  printf("%d\n",MAX);
    printf("%d\n",M);
  return 0;
}

MAX的值就是100。MAX通通会被替换成100

M会在预处理阶段被替换成3+5，不会计算成8

【使用例子2】定义字符串

#include<stdio.h>
#define STR "abcde"
int main()
{
  printf(STR);
  return 0;
}

【使用例子3】定义类型

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

【使用例子4】可以替换成很多其他例子

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

注意：#define定义后面最后不要加分号（；）

（2）#define定义宏

【定义】

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

#define name( parament-list ) stuff
//其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

图解：

注意事项1：参数列表的左括号必须与name紧邻。

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

【使用例子1】宏的使用

#include<stdio.h>
#define ADD(x,y) (x+y)
int main()
{
  int a = 3;
  int b = 5;
  int c = ADD(a,b);
  printf("%d\n",c);
  return 0;
}

替换过程：

【使用注意事项】括号的添加

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

我们会以为结果是40，其实不是

ADD会被替换成3+5，然后5*3+5才是最终处理的结果。

所以宏体需要添加括号。

做法：

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

（3）#define替换规则

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

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

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

（4）#和##

【#的作用】把一个宏参数变成对应的字符串。

我们先看一段代码：

#include<stdio.h>
int main()
{
  int a = 10;
  printf("the value of a is %d\n", a);
  int b = 10;
  printf("the value of a is %d\n", b);
  float c = 3.14;
  printf("the value of a is %f\n", c);
  return 0;
}

每一个printf中都有重复的内容，是否可以将其包装起来呢？因为函数无法传类型，所以我们可以用宏

#include<stdio.h>
#define PRINT(n,format) printf("the value of ""n"" is "format"\n", n)
int main()
{
  int a = 10;
  PRINT(a, "%d");
  int b = 10;
  PRINT(b, "%d");
  float c = 3.14;
  PRINT(c, "%lf");
  return 0;
}

宏替换后：

【正确做法】需要用到#

#include<stdio.h>
#define PRINT(n,format) printf("the value of "#n" is "format"\n", n)
int main()
{
  int a = 10;
  PRINT(a, "%d");
  int b = 10;
  PRINT(b, "%d");
  float c = 3.14;
  PRINT(c, "%lf");
  return 0;
}

这样就可以把宏参数n替换成对应的字符串。比如a传给n，n是一个宏参数，替换成对应的宏参数就是a。

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

【例子】

#include<stdio.h>
#define CAT(n,v) n##v
int main()
{
  int value10 = 666;
  printf("%d\n",CAT(value,10));
  return 0;
}

输出结果：666

##会把左右两个符号连接成一个符号，n##v就变成nv，于是value，10就变成了value10，就是666.

注意：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

（5）带副作用的宏参数

什么是副作用，例如++或者--操作赋，如a++之后a的值发生了改变，这就是副作用，宏参数使用这种操作符也会有这种后果。

x+1;//不带副作用
x++;//带有副作用

【例子】

#include<stdio.h>
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
  int x = 5;
  int y = 8;
  int z = MAX(x++, y++);
  printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
  return 0;
}

这就是宏参数的副作用

（6）宏和函数对比

【宏的优点】

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。

所以宏比函数在程序的规模和速度方面更胜一筹。

2. 更为重要的是函数的参数必须声明为特定的类型。

所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

宏的参数可以是类型：

#include<stdio.h>
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main()
{
  int* p = MALLOC(10,int);
  if (p == NULL)
  {
    return;
  }
  return 0;
}

【宏的缺点】

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

2. 宏是没法调试的。

3. 宏由于类型无关，也就不够严谨。

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

【宏与函数的对比】

（7）命名约定

把宏名全部大写

函数名不要全部大写

3.#undef

（1）定义

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

（2）

#include<stdio.h>
#define M 100
int main()
{
  printf("%d\n",M);
#undef M//移除
#define M 520//重新赋值
  printf("%d\n",M);
  return 0;
}

4..命令行定义

（1）定义

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

就如Java在控制台操作一样

（2）作用

当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假

定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大写，我们需要一个数组能够大写。）

当前VS无法验证

5.条件编译

（1）定义

可以选择性选择某一条代码进行编译

如：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

（2）第一种条件编译指令

【形式】

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

【代码】

#include<stdio.h>
int main()
{
#if 1
  printf("我喜欢你\n");
#endif
#if 0
  printf("我不喜欢你\n");
#endif
  return 0;
}

运行起来看结果：

（3）第二种条件编译指令

【形式】这种用于多分支的条件编译，如if…else if…else语句类似

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

无论什么情况，最多也只会选择一块代码进行编译。

【代码】

#include<stdio.h>
int main()
{
#if 1
  printf("我喜欢你\n");
#elif 1
  printf("我不喜欢你\n");
#elif 1==100
  printf("爱你一生一世\n");
#else
  printf("不爱你\n");
#endif
  return 0;
}

运行结果：

（4）判断是否被定义

【形式1】

#if defined(symbol)
    //语句
#endif

#include<stdio.h>
#define M 200
int main()
{
#if defined(M)
  printf("如果M被定义则会打印这句话\n");
#endif
#if defined(N)
  printf("如果N被定义则会打印这句话\n");
#endif
  return 0;
}

它只会判断这个符号是否存在，不会判断其值的真假

【形式2】

#ifdef 符号
    //语句
#endif

#include<stdio.h>
#define M 200
int main()
{
#ifdef M
  printf("如果M被定义则会打印这句话\n");
#endif
#ifdef N
  printf("如果N被定义则会打印这句话\n");
#endif
  return 0;
}

【形式3】

#if !defined(symbol)
    //语句
#ifndef symbol

include<stdio.h>
#define M 200
int main()
{
#if !defined(M)
  printf("如果M没有被定义则会打印这句话\n");
#endif
#if !defined(N)
  printf("如果N没有被定义则会打印这句话\n");
#endif
  return 0;
}

（5）嵌套指令

【形式】

#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

6.头文件包含

（1）两种头文件包含的形式

1.包含本地的文件（自己的.h文件）

#include"xxxxxx.h"

2.包含标准库的头文件

#include<xxxx.h>

【本地文件包含】#include"xxxxxx.h"

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

如果找不到就提示编译错误。

【库文件包含】#include<xxxx.h>

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

写的时候需要区分不同种类的头文件

（2）嵌套头文件

嵌套使用头文件会增加程序的负担，所以每个头文件只需要被包含一次即可

【方法1】使用条件编译

每个头文件的开头写：

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

【方法2】在头文件前加上这一句话

#pragma once