04.9.4 编译链接全过程
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.9 C 与 C++
覆盖范围
- 预处理:宏展开、头文件展开、条件编译
- 编译:词法分析、语法分析、语义分析、中间代码生成、优化
- 汇编:汇编代码转机器指令,生成 .o 目标文件
- 链接:符号解析、重定位、静态库/动态库链接
- name mangling、extern "C"、链接错误排查
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.9.4-001 | 编译四阶段分别做什么 | 基础 | ★★★★★ |
| 04.9.4-002 | 预处理阶段做什么 | 基础 | ★★★★☆ |
| 04.9.4-003 | 什么是 name mangling | 进阶 | ★★★★☆ |
| 04.9.4-004 | 静态库和动态库的区别 | 进阶 | ★★★★☆ |
| 04.9.4-005 | 什么是定义声明,什么是声明 | 基础 | ★★★★★ |
| 04.9.4-006 | 链接时常见错误有哪些 | 进阶 | ★★★★☆ |
| 04.9.4-007 | extern "C" 解决什么问题 | 进阶 | ★★★★☆ |
| 04.9.4-008 | 强符号和弱符号是什么 | 高级 | ★★★★☆ |
04.9.4-001 一个 C++ 程序从源码到可执行文件经历哪几个阶段?
频率 ★★★★★ | 难度 基础
一句话结论
四个阶段:预处理(预处理器)→ 编译(编译器生成汇编)→ 汇编(汇编器生成目标文件)→ 链接(链接器把目标文件和库合成可执行文件)。
概念解释
- 预处理:处理 #include、#define、#if 等预处理指令,生成 .i 文件。
- 编译:词法分析、语法分析、语义分析、生成中间代码、优化,生成 .s 汇编文件。
- 汇编:把汇编代码翻译成机器指令,生成 .o(Windows 是 .obj)目标文件。
- 链接:把多个 .o 文件和库文件合并,解析符号引用,重定位地址,生成可执行文件。
原理流程
- 编译器驱动(gcc/g++)依次调用四个工具:cpp(预处理器)、cc1(编译器)、as(汇编器)、ld(链接器)。
- 每个 .cpp 文件独立编译成 .o 文件,互相之间不知道对方的存在。
- 链接阶段把所有 .o 文件放在一起,解析每个函数/变量引用的是哪个 .o 里的定义。
- 最后把代码段、数据段合并,重定位地址,生成可执行文件。
代码 / 示例
# 手动分步编译
g++ -E main.cpp -o main.i # 预处理
g++ -S main.i -o main.s # 编译生成汇编
g++ -c main.s -o main.o # 汇编生成目标文件
g++ main.o utils.o -o app # 链接生成可执行文件
# 一步到位
g++ main.cpp utils.cpp -o app
常见误区
- 误区:编译器就是整个过程?正解:编译器驱动只是入口,内部调用了四个独立工具。
- 误区:所有 .cpp 文件一起编译?正解:每个 .cpp 独立编译成 .o,最后才链接。
追问 / 延伸
- 为什么要分这么多阶段?正解:模块化,每个阶段可以单独优化,也可以单独调试。
- 增量编译是什么?答:只重新编译修改过的 .cpp,没修改的用之前的 .o,节省时间。
04.9.4-002 预处理阶段做哪些事情?
频率 ★★★★☆ | 难度 基础
一句话结论
预处理处理所有 # 开头的指令:#include 把头文件内容原样插入、#define 做宏文本替换、#if/#ifdef 做条件编译、#pragma 给编译器发指令,最终生成一个纯文本的 .i 文件。
概念解释
- #include:把头文件内容复制到当前位置,递归展开。
- #define:定义宏,做文本替换(不是类型安全的)。
- #if/#ifdef/#ifndef/#endif:条件编译,根据条件决定是否包含某段代码。
- #pragma:给编译器发特殊指令,比如 once、pack。
- 注释:预处理阶段会删除注释。
原理流程
- 预处理器逐行读源文件。
- 遇到 #include 就打开那个头文件,把内容插进来,递归处理。
- 遇到 #define 就记录宏名,后面遇到就替换成宏体。
- 遇到 #if 就判断条件,条件为假就跳过这段代码。
- 输出一个没有预处理指令、没有注释的纯 C++ 代码文件。
代码 / 示例
// 预处理前
#include <iostream>
#define MAX 100
#ifdef DEBUG
void log(const char* msg) { std::cout << msg << std::endl; }
#else
void log(const char* msg) {}
#endif
int main() {
std::cout << MAX << std::endl;
return 0;
}
// 预处理后(.i 文件)
// iostream 的全部内容...
void log(const char* msg) {} // 因为没定义 DEBUG
int main() {
std::cout << 100 << std::endl; // MAX 被替换成 100
return 0;
}
常见误区
- 误区:宏是类型安全的?正解:宏只是文本替换,不管类型,容易出 bug;现代 C++ 推荐用 const 常量和 inline 函数。
- 误区:#include 是把函数库链接进来?正解:#include 只是把头文件的声明插进来,链接是后面的事。
追问 / 延伸
- #pragma once 和 #ifndef 头文件保护有什么区别?答:#ifndef 是标准的,所有编译器都支持;#pragma once 是编译器扩展,更高效但不是所有编译器都支持。
- 宏和 inline 函数哪个好?答:inline 函数有类型检查、作用域检查,更安全;宏只有在真正需要文本替换的场景(比如 #line、offsetof)才用。
04.9.4-003 什么是 name mangling?为什么 C++ 需要它?
频率 ★★★★☆ | 难度 进阶
一句话结论
name mangling(名字修饰)是编译器把函数名、参数类型编码成唯一字符串的过程,因为 C++ 支持函数重载(同名不同参数),链接器需要区分它们;C 不支持重载,所以不需要 mangling。
概念解释
- C 语言:函数名就是符号名,比如
foo()编译后符号就是foo。 - C++:支持函数重载,
foo(int)和foo(double)同名但参数不同,需要编码成不同的符号名。 - 不同编译器的 mangling 规则不一样,所以 g++ 编译的库和 MSVC 编译的库不能直接链接。
- extern "C" 告诉编译器:这个函数按 C 的方式编译,不要 mangling。
原理流程
- C++ 编译器把函数名、命名空间、参数类型、const 限定等信息编码成一个字符串。
- 比如
namespace ns { void foo(int x); },g++ 编译后符号可能是_ZN2ns3fooEi。 - 链接器按这个编码后的名字找符号。
- 如果 C++ 代码要调用 C 写的库,C 库的符号没有 mangling,直接链接会找不到,因为 C++ 编译器找的是 mangled 过的名字。
代码 / 示例
// C++ 代码
void foo(int x) {}
void foo(double x) {} // 重载
// 编译后符号名(g++):
// _Z3fooi
// _Z3food
// 用 nm 看目标文件的符号
// nm main.o | grep foo
// 0000000000000000 T _Z3fooi
// 0000000000000000 T _Z3food
// extern "C" 告诉编译器不要 mangling
extern "C" {
void c_style_func(int x) {} // 符号就是 c_style_func,没有 mangling
}
// 这样 C 代码就可以调用这个函数
常见误区
- 误区:C++ 函数名编译后还是原来的名字?正解:会被 mangling 成一串编码,只有 extern "C" 的才保持原名。
- 误区:所有 C++ 编译器的 mangling 规则都一样?正解:不一样,g++、clang、MSVC 的规则都不同,所以跨编译器链接 C++ 库很麻烦。
追问 / 延伸
- 怎么看 mangled 名字?答:用
nm看符号,用c++filt反 demangle。 - 为什么 C 不需要 mangling?答:C 不支持函数重载,每个函数名就是唯一的,不需要区分。
04.9.4-004 静态库和动态库有什么区别?
频率 ★★★★☆ | 难度 进阶
一句话结论
静态库在链接时把代码全部复制到可执行文件里,运行时不需要库文件;动态库在运行时才加载,多个程序可以共享同一份库代码,文件小但部署时要带库。
概念解释
- 静态库:.a(Linux)/ .lib(Windows),链接时把库的代码全部拷贝到可执行文件中。
- 动态库:.so(Linux)/ .dll(Windows)/ .dylib(macOS),运行时才加载,可执行文件里只存函数地址。
- 静态库优点:部署简单,一个文件就能跑;缺点:可执行文件大,库更新要重新编译。
- 动态库优点:多个程序共享内存,库更新不用重新编译;缺点:部署时要带库,版本兼容性问题。
原理流程
- 静态库链接:链接器把库中被用到的函数代码复制到可执行文件的代码段。
- 动态库链接:链接器在可执行文件里记录需要哪个动态库、哪个函数,不复制代码。
- 运行时:操作系统加载器看到可执行文件依赖某个 .so,就把它映射到进程地址空间,解析函数地址。
- 多个进程用同一个动态库时,内存里只有一份代码段,节省内存。
代码 / 示例
# 编译静态库
g++ -c utils.cpp -o utils.o
ar rcs libutils.a utils.o # 打包成静态库
# 链接静态库
g++ main.o -L. -lutils -o app_static
# 编译动态库
g++ -shared -fPIC utils.cpp -o libutils.so
# 链接动态库
g++ main.o -L. -lutils -o app_dynamic
# 运行时需要让系统找到 libutils.so
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./app_dynamic
常见误区
- 误区:静态库链接时会把整个库都塞进去?正解:链接器只复制被用到的目标文件,不是整个库。
- 误区:动态库一定比静态库快?正解:动态库有加载和重定位开销,启动时慢一点;运行时因为共享代码,内存更省。
追问 / 延伸
- 什么是 -fPIC?答:Position Independent Code,位置无关代码,动态库需要,这样库可以加载到任意地址。
- Windows 的 DLL 导出函数怎么声明?答:__declspec(dllexport) 导出,__declspec(dllimport) 导入。
04.9.4-005 什么是声明?什么是定义?
频率 ★★★★★ | 难度 基础
一句话结论
声明只是告诉编译器这个名字存在、类型是什么,不分配内存;定义才真正分配内存、给出实现;头文件里放声明,源文件里放定义。
概念解释
- 声明:
extern int x;、void foo(int);— 告诉编译器有这个东西,但不分配内存。 - 定义:
int x = 10;、void foo(int x) { ... }— 真正分配内存、给出实现。 - 一个变量可以声明多次,但只能定义一次。
- 头文件里放声明,源文件里放定义,避免重复定义。
原理流程
- 头文件里放函数声明和 extern 变量声明。
- 多个源文件 include 这个头文件,相当于都声明了这些名字。
- 链接时,从某个源文件的定义里找到真正的实现,所有声明都指向同一个定义。
- 如果多个源文件都定义了同一个全局变量,链接时会报"重复定义"错误。
代码 / 示例
// utils.h
#ifndef UTILS_H
#define UTILS_H
extern int g_count; // 声明,不分配内存
void foo(int x); // 声明,不分配内存
#endif
// utils.cpp
#include "utils.h"
int g_count = 0; // 定义,分配内存
void foo(int x) { g_count += x; } // 定义
// main.cpp
#include "utils.h"
int main() {
g_count = 10; // 使用声明的变量
foo(5); // 使用声明的函数
return 0;
}
常见误区
- 误区:头文件里定义变量不会有问题?正解:如果头文件里写
int x;,每个 include 它的源文件都会有一份 x 的定义,链接时重复定义错误。 - 误区:const 变量在头文件里也会重复定义?正解:C++ 中 const 变量默认是内部链接(internal linkage),每个翻译单元有自己的一份,不会报重复定义。
追问 / 延伸
- 什么是内部链接和外部链接?答:内部链接是每个源文件独立一份,外部链接是整个程序共享一份。
- inline 函数为什么可以在头文件里定义?答:inline 函数允许多次定义,只要每个定义都一样,链接器会合并成一个。
04.9.4-006 链接时常见的错误有哪些?
频率 ★★★★☆ | 难度 进阶
一句话结论
最常见的链接错误:undefined reference(找不到函数或变量的定义)、multiple definition(重复定义)、cannot find -lxxx(找不到库文件)、版本不匹配(动态库版本不对)。
概念解释
- undefined reference:调用了一个函数,但链接器在所有 .o 和库文件里都找不到它的定义。
- multiple definition:同一个符号在多个 .o 文件里都定义了,链接器不知道用哪个。
- cannot find -lxxx:链接器找不到 libxxx.so 或 libxxx.a。
- undefined symbol:动态库加载时找不到符号。
原理流程
- 链接器扫描所有 .o 文件,收集符号表。
- 遇到一个符号引用,就去所有 .o 和库文件里找它的定义。
- 找不到就报 undefined reference。
- 找到多个定义就报 multiple definition。
- 库文件找不到路径就报 cannot find -lxxx。
代码 / 示例
# 错误一:undefined reference to `foo(int)'
# 原因:main.cpp 调用了 foo,但没把实现 foo 的 utils.o 链接进来
g++ main.cpp -o app
# 解决:把 utils.cpp 也加进来
g++ main.cpp utils.cpp -o app
# 错误二:multiple definition of `g_count'
# 原因:g_count 在多个 .cpp 里都定义了
# 解决:头文件里用 extern 声明,只在一个 .cpp 里定义
# 错误三:cannot find -lutils
# 原因:链接器找不到 libutils.so 或 libutils.a
# 解决:加 -L 指定库路径,或者把库放到系统库目录
g++ main.o -L./lib -lutils -o app
常见误区
- 误区:undefined reference 是编译错误?正解:是链接错误,编译只看声明,链接才找定义。
- 误区:库文件放对路径就一定能找到?正解:Linux 还要看 LD_LIBRARY_PATH 或 ldconfig 缓存,Windows 要把 dll 放 PATH 里。
追问 / 延伸
- 怎么调试链接错误?答:用
nm看 .o 文件里的符号,用ldd看可执行文件依赖哪些动态库。 - 什么是静态链接和动态链接?答:静态链接是链接时把库代码复制进来,动态链接是运行时才加载。
04.9.4-007 extern "C" 解决什么问题?
频率 ★★★★☆ | 难度 进阶
一句话结论
extern "C" 告诉 C++ 编译器:这个函数按 C 的方式编译,不要做 name mangling,这样 C++ 代码就可以调用 C 语言写的库,C 代码也可以调用 C++ 导出的函数。
概念解释
- C++ 的函数名会被 mangling,比如
foo(int)变成_Z3fooi。 - C 语言的函数名就是原名,比如
foo就是foo。 - 如果 C++ 代码直接调用 C 写的库,C++ 编译器会找 mangled 过的名字,找不到,链接报错。
- extern "C" 让编译器不要 mangling,符号名就是原名,两边就能对上。
原理流程
- C++ 代码里写
extern "C" void foo(int x);。 - 编译器编译这个函数时,符号名就是
foo,不做 mangling。 - C 语言写的库,符号名也是
foo。 - 链接时两边对上,成功。
代码 / 示例
// C++ 代码调用 C 写的库
extern "C" {
#include "c_utils.h" // C 头文件
}
int main() {
c_function(42); // C 函数,符号名就是 c_function
return 0;
}
// C++ 代码导出函数给 C 用
extern "C" {
void cpp_function(int x) { // 符号名就是 cpp_function,没有 mangling
// ...
}
}
常见误区
- 误区:extern "C" 可以放在 C 代码里?正解:extern "C" 是 C++ 语法,C 编译器不认识;C 头文件里用
#ifdef __cplusplus包起来。 - 误区:extern "C" 里面可以写 C++ 类?正解:不行,extern "C" 只影响链接方式,里面的代码还是 C++ 语法,但不能有类成员函数(因为成员函数也有 this 指针,需要 mangling)。
追问 / 延伸
- 为什么 C 库的头文件里都有
#ifdef __cplusplus extern "C" { #endif?答:这样 C++ 代码 include 时自动加 extern "C",C 代码 include 时不影响。 - 什么是跨语言调用?答:C++ 调 C、C 调 C++、Java 调 C++(JNI)等,都需要统一的符号命名规则。
04.9.4-008 什么是强符号和弱符号?
频率 ★★★★☆ | 难度 高级
一句话结论
强符号是函数和已初始化的全局变量,弱符号是未初始化的全局变量和用 attribute((weak)) 声明的符号;链接规则是:多个强符号报错,一个强符号加多个弱符号用强符号,多个弱符号选一个。
概念解释
- 强符号:函数定义、已初始化的全局变量。
- 弱符号:未初始化的全局变量(C 语言中默认是弱符号)、用 attribute((weak)) 声明的符号。
- 链接器的规则:
- 不允许同一个符号有多个强定义。
- 一个强定义和多个弱定义,用强定义。
- 多个弱定义,选一个(通常是第一个)。
- 弱符号常用于库的默认实现:用户可以定义强符号覆盖默认实现。
原理流程
- 链接器收集所有 .o 文件的符号表。
- 每个符号标记是强还是弱。
- 如果同一个符号有多个强定义,报"重复定义"错误。
- 如果有一个强定义,其他都是弱定义,用强定义,弱定义被忽略。
- 如果都是弱定义,选一个,其他被忽略。
代码 / 示例
// lib.c
__attribute__((weak)) void debug_log(const char* msg) {
// 默认的弱实现,什么都不做
}
// main.c
void debug_log(const char* msg) {
// 用户的强实现,打印日志
printf("DEBUG: %s\n", msg);
}
// 链接时:强定义覆盖弱定义,main.c 的实现生效
// 如果用户没定义 debug_log,就用弱的默认实现,不会链接错误
常见误区
- 误区:未初始化的全局变量是强符号?正解:C 语言中未初始化的全局变量是弱符号(common symbol),C++ 中是强符号。
- 误区:弱符号就是没用的符号?正解:弱符号是库的重要设计手段,提供默认实现让用户可以覆盖。
追问 / 延伸
- 什么是链接时覆盖?答:用户定义强符号,库的弱符号被覆盖,不用修改库代码就能改变行为。
- C++ 为什么把未初始化全局变量改成强符号?答:为了避免 C 语言中"多个未初始化全局变量居然能链接成功"的坑。
待整理清单
- [ ] 链接器详细算法(ELF 格式、重定位表)
- [ ] 模板编译分离模型(include 模型 vs 分离模型)
- [ ] LTO(链接时优化)原理
- [ ] 动态链接器装载过程