当前位置：首页 > news >正文

C语言——编译与链接

news 来源：原创 2025/6/8 8:31:56

前言

一程序的两种环境

1翻译环境

2执行环境

二预处理

1预处理符号

2#define

2.1#define 定义标识符

2.2#define 定义宏

2.2.1#和##

2.3带副作用的宏参数

2.4宏和函数的比较

2.5命名约定

3#undef

4命令行定义

5条件编译

5.1单分支

5.2多分支

5.3判断是否被定义

5.4嵌套形式

6文件包含

6.1本地文件包含

6.2库文件包含

6.3嵌套文件包含

前言

写完代码后，让代码‘跑’起来的过程，你是否有过疑问：VS是怎么把我们所写的代码变成让电脑读懂并能执行的可执行程序?学完C语言的编译与链接后，你或许就有答案了~

一程序的两种环境

写代码中，存在着两种不同的环境：

一种种是翻译环境：在这个环境中源代码被转换为可执行的机器指令；
一种种是执行环境：它用于实际执行代码

1翻译环境

在翻译环境中共分为两大步：编译与链接；

编译：组成一个程序的每个源文件通过 编译器 转换成目标代码（object code），形成目标文件；
链接：每个目标文件由 链接器 捆绑在一起，形成一个单一而完整的可执行程序；

在window环境中，目标文件是以 .obj 结尾的文件；而可执行程序以 .exe 结尾的文件

而编译本身也分为3步：预编译(预处理)，编译，汇编

由于VS不好演示各个阶段生成的文件来观察现象，我们用Linux环境来演示

先准备一段代码：

#include <stdio.h>#define M 100
// 主函数入口
int main()
{int a = 10;int b = 20;printf("hehe\n");//下面是代码int c = a + b;int d = M;printf("%d", d);return 0;
}

预处理选项 gcc -E test.c -o test.i 生成的test.i文件与原文件进行对比

改变：

1将注释进行替换成空格；

2头文件的包含，#define的替换，这些都是预处理指令，都是在预处理下进行处理的

编译选项 gcc -S test.i -o test.s

把C语言代码翻译成汇编代码，包括：

1词法分析；2语法分析；3语义分析；4符号分析(全局变量/函数的分析)

汇编选项 gcc -c test.c -o test.o

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

(生成符号表)

在编译期间的符号分析如全局变量/函数分别对应不同的地址储存，每个文件生成自己独立的符号表

链接选项选项 gcc test.o -o test.exe

链接将目标文件和链接库生成可执行的二进制的程序，链接过程包括：

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

2执行环境

程序执行的过程：

1. 程序必须载入内存中；在有操作系统的环境中：一般这个由操作系统完成；在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
2. 程序执行，调用main函数； 3. 执行程序代码；这个时候程序将使用一个运行时堆栈（函数栈帧空间），存储函数的局部变量和返回地址；
4. 终止程序；正常终止main函数；也有可能是意外终止

二预处理

1预处理符号

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

#include<stdio.h>int main()
{printf("%s\n",__FILE__);printf("%d\n",__LINE__);printf("%s\n",__DATE__);printf("%s\n",__TIME__);printf("%d\n",__STDC__);//说明gcc遵守return 0;
}

2#define

2.1#define 定义标识符

#define MAX 1000
#define INT int
#define forever for(;;) //用更形象的符号来替换一种实现// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf( \"file:%s line:%d\ndate:%s time:%s\n", \__FILE__,__LINE__ , \__DATE__,__TIME__ )
int main()
{DEBUG_PRINT;return 0;
}

注意：#define定义标识符时千万不要加分号(;)，不然你将会见到意想不到的错误，如：

明明有加括号却报错了！就是因为#define替换把；给替换上了，造成语法错误

2.2#define 定义宏

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

使用：

#include <stdio.h>#define Add(a, b) a + b // 没有;int main()
{int i = 10, j = 20;printf("%d\n", Add(i, j));return 0;
}

结果：

这样使用有点类似函数实现Add功能：但两者使用上有不同，如果是下面的情况：

#include <stdio.h>#define Add(a, b) a + b // 没有;int main()
{int i = 10, j = 20;printf("%d\n", 3 * Add(i, j));//预期是90return 0;
}

结果：

怎么是50？？

我们将代码进行预处理来观察现象：

原来是优先级运算的问题：前面乘法先计算导致结果不是所预期的那样；

这也就是在使用#define 宏时我们要注意优先级：通常就是定义时加上括号

(参数同时也要加上括号，因为你不知道在调用宏时传的是不是表达式)

#define Add(a,b) ((a)+(b)) //没有;int main()
{int i=10,j=20;printf("%d\n",3*Add(i,j));//预期是90return 0;
}

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

2.2.1#和##

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

#include <stdio.h>int main()
{int a = 10;printf("the value of a is %d\n", a);char c = 'w';printf("the value of c is %c\n", c);float f = 3.14f;printf("the value of f is %f\n", f);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");// printf("the value of a is %d\n",a);char c = 'w';Print(c, "%c");// printf("the value of c is %c\n",c);float f = 3.14f;Print(f, "%f");// printf("the value of f is %f\n",f);return 0;
}

结果是一样的！

可以这么说：#n 的出现实现还原回去传进来时的参数名

而##的作用：则是将两个宏参数进行拼接使用（有点怪奇葩的）

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

2.3带副作用的宏参数

什么是副作用？

    x+1//x本身没改变x++//x本身被改变了，所以执行该语句有副作用

实现：比大小之后返回最大值的函数/宏

#include <stdio.h>#define Max1(a, b) ((a) > (b) ? a : b)int Max2(int a, int b)
{return a > b ? a : b;
}int main()
{int i = 10, j = 20;int m = Max1(i, j);printf("%d\n", m);m = Max2(i, j);printf("%d\n", m);return 0;
}

看似实现出来使用上没问题，但如果是以下情况：

#include <stdio.h>#define Max1(a, b) ((a) > (b) ? a : b)int Max2(int a, int b)
{return a > b ? a : b;
}int main()
{int i = 10, j = 20;int m = Max1(i++, j++);printf("%d\n", m);m = Max2(i++, j++);printf("%d\n", m);return 0;
}

表面上看上去：i++，j++后还是j最大，输入应该是21，怎么宏实现出来的是22？？

将代码进行预处理后就能得到答案：原来j++了两次

所以对于需要改变参数值的实现形式：用函数更为靠谱；

但我们上面又见过一种实现方式宏能实现，而函数实现不了；那么究竟宏和函数之间各有什么优劣呢？

2.4宏和函数的比较

两者的优点与缺点都是相对应的；

宏的优点：

1.通常由于处理简单运算：执行与处理都比函数要快很多（体现在汇编中）；
2. 宏是类型无关的：所以在用于比较中，传入能比较的如何变量类型都可以，而函数参数开始就被固定了（设计函数需要设计参数类型）

宏的劣势：

1.宏不方便进行调试：所以出错时进行解决通常被函数要慢很多； 2.宏与类型无关，使用时就不够严谨，较容易出现错误； 3.设计宏时一定要检查运算符优先级的问题（上面代码演示过）

宏有时候能做到函数做不到的事（上面#的例子是一个）如要传类型进行使用时（函数就做不到传类型进行使用）

#include <stdio.h>
#include <stdlib.h>#define MALLOC(num, type) (type *)malloc(num * sizeof(type))int main()
{// 实现malloc(5,int)MALLOC(5, int);return 0;
}

2.5命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者；
所以我们平时的一个习惯是：

宏名全部大写；
函数名不要全部大写

3#undef

用于移除一个宏定义

#include <stdio.h>#define M 100int main()
{int m = M;printf("m=%d\n", m);
#undef M
// 移除后M还能再次定义
#define M 1000int n = M;printf("n=%d\n", n);return 0;
}

4命令行定义

在gcc中：如果不把变量进行初始化，可以在使用命令行进行编译时指定它的大小

gcc -D Name=10

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

5条件编译

如果我写了不同环境下的多份代码，即将在不同环境下进行编译，要想其它代码不干扰编译，我们可以选择使用条件编译对其它代码进行屏蔽达到目的

5.1单分支

5.2多分支

5.3判断是否被定义

5.4嵌套形式

6文件包含

6.1本地文件包含

#include "filename"

查找策略：

先在源文件所在目录下查找；

如果该头文件未找到编译器就像查找库函数头文件一样在标准位置查找头文件；
找不到就提示编译错误

6.2库文件包含

#include <filename.h>

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

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

6.3嵌套文件包含

这样使用时tet,c包含两份comm.h，造成文件重复

解决：

//方法1
#ifdnef __TEST_H__ //没被定义就编译该文件的内容#define __TEST_H__//内容       #endif __TEST_H__//第二就不会编译内容里面的代码(因为__TEST_H__存在了)//方法二
#pragma once //加上这句就表示该文件只需被编译一次

以上便是全部内容，有问题欢迎在评论区指正，感谢观看！

前言

一程序的两种环境

1翻译环境

2执行环境

二预处理

1预处理符号

2#define

2.1#define 定义标识符

2.2#define 定义宏

2.2.1#和##

2.3带副作用的宏参数

2.4宏和函数的比较

2.5命名约定

3#undef

4命令行定义

5条件编译

5.1单分支

5.2多分支

5.3判断是否被定义

5.4嵌套形式

6文件包含

6.1本地文件包含

6.2库文件包含

6.3嵌套文件包含

相关文章：