g++演示如何从C++代码到可执行程序

Vect_

发布于 2025-12-18 18:02:47

1790

🎬 个人主页：Vect个人主页 🎬 GitHub：Vect的代码仓库 🔥 个人专栏: 《数据结构与算法》《C++学习之旅》《Linux》

⛺️Per aspera ad astra.

1. C++如何从代码到可执行文件

1.0. 一小段代码进行演示

// add.h
#pragma once 

template <class T>
T add(T a, T b){
  return a + b;
}

// foo.cpp
#include "add.h"

int foo(){
  return add(10,30);        // add<int>实例化
}

// main.cpp
#include "add.h"
#include <iostream>
using namespace std;

int foo();

int main(){
  cout<<add(1,2)<<endl;
  cout<<foo()<<endl;

  return 0;
}

1.1. 预处理阶段: `g++ -E`

预处理阶段编译器只做文本级工作：

展开#include：把头文件的内容拷贝进来
宏替换#define
条件编译#if/#ifdef
去掉注释

注意：模板实例化不在预处理阶段，预处理器不懂C++语义，只做文本级处理

命令演示

[vect@VM-0-11-centos ~]$ g++ -E main.cpp -o main.i
[vect@VM-0-11-centos ~]$ g++ -E foo.cpp -o foo.i

-E:只执行预处理操作，预处理结束就停止 -o：指定输出文件名，后面紧跟文件名 filename.i：预处理后的源文件后缀为.i 如果不加 -o main.i 预处理过后的文件会输出到终端

1.2.编译阶段：`g++ -S`

把预处理后的.i文件变成汇编文件.s：

词法/语法分析： 把字符流变成token流（我们写的代码对于机器来说就是一串字符，编译器会把这串字符组合成有意义的”单词“即token流）；判断token流的排列是否符合C++语法并构建AST树(抽象语法树)

写的一行代码：int a = b + 3; 在计算机眼里就是一串字符：i n t a = b + 3 ;,现在把这些字符组成有意义的token，具体包括了关键字、标识符、运算符、字面量、语句结束符，这个阶段只关心”单词的构建“，不关系语法是否正确
现在已经形成token流[int] [a] [=] [b] [+] [3] [;]，语法分析的结果不是对与错，而是构建AST树（这句代码真正的结构含义）

然后补充上类型信息：

声明语句
 ├── 类型: int
 └── 赋值
     ├── 变量: a
     └── 加法
         ├── 变量: b
         └── 常量: 3

这里可以类比：词法分析-认识单词语法分析-分析句子主谓宾 AST-句子的语法树状图

语义分析： 类型检查、重载检查、名字查找、访问控制、模板相关规则

模板实例化： 当编译器看到”需要用到的模板“时，会生成具体版本的函数体，例如：add(1,2)--->add<int>(int,int)

优化： 基于AST树，修改AST树，常量折叠(直接进行运算，不留到运行期int x = 5 + 3 -> int x = 8)、内联（直接替换函数调用，在这里展开函数，内联只是建议）、死代码删除（删除永远不会执行的代码）、寄存器分配…

生成汇编： 输出.s

命令演示：

[vect@VM-0-11-centos ~]$ g++ -S main.i -o main.s
[vect@VM-0-11-centos ~]$ g++ -S foo.i -o foo.s

可以观察到，此时已经形成了汇编代码

1.3. 汇编阶段：`g++ -c`

汇编把.s汇编代码变成机器码目标文件（二进制文件）.o，二进制文件包含：

.text段：机器指令

.rodata：只读常量

.data/.bss：全局/静态数据

符号表： 目标文件中定义了哪些符号、还需要外部提供哪些符号

符号：函数名、全局变量名、静态变量名

符号表：**目标文件里的一张”名字->状态/地址“**的表，回答定义了哪些符号，使用了哪些符号但是还不知道地址，举个例子理解一下：

// show_signal.cpp
int foo(){return 23;}

编译：

[vect@VM-0-11-centos ~]$ g++ -c show_signal.cpp -o foo.o
[vect@VM-0-11-centos ~]$ nm -C foo.o	# 查看符号表
                 U __cxa_atexit
                 U __dso_handle
0000000000000048 t _GLOBAL__sub_I__Z3foov
0000000000000000 T foo()
000000000000000b t __static_initialization_and_destruction_0(int, int)
                 U std::ios_base::Init::Init()
                 U std::ios_base::Init::~Init()
0000000000000000 b std::__ioinit

0000000000000000 T foo() 偏移地址在.text段中定义符号名

说明了在foo.o里面，自己定义了foo

再看需要外部提供符号的情况：

int foo(); // 声明未定义

int main(){
  return foo();
}

编译：

[vect@VM-0-11-centos ~]$ g++ -c main_signal.cpp -o main.o
[vect@VM-0-11-centos ~]$ nm -C main.o
                 U __cxa_atexit
                 U __dso_handle
0000000000000048 t _GLOBAL__sub_I_main
0000000000000000 T main
                 U foo()
000000000000000b t __static_initialization_and_destruction_0(int, int)
                 U std::ios_base::Init::Init()
                 U std::ios_base::Init::~Init()
0000000000000000 b std::__ioinit

看这段代码：

0000000000000000 T main
                 U foo()

U = undefined未定义，这里说明在mian.o中用到了foo()，但是在mian.o中没有实现，需要外部提供的符号！

所以符号表的作用： 当链接器拿到main.o发现需要foo，而foo.o定义了foo，则指向foo.o里的foo地址

重定位信息： 哪些地址等链接时再决定

一个残酷的事实：在.o文件中，所有地址都是临时的！！！ 因为.o不知道将来和谁链接，不知道程序从内存哪里开始，所以编译器只能做到：将来这里要用一个地址，我先占个坑
举个例子：

int foo(); // 声明未定义

int main(){
  return foo();
}

在汇编层面： call _Z3foov 这里foo被改名为_Z3foov，这里可以补充一个知识点：为什么C++支持函数重载？在汇编和链接层面，名字必须唯一，C++函数会进行函数名改编，把函数名编进符号表里

_Z  3  foo  v
│   │   │    │
│   │   │    └── 参数列表：v = void（无参数）
│   │   └─────── 函数名 foo
│   └─────────── 3 表示 foo 这个名字长度是 3
└─────────────── _Z = C++ 符号前缀

void foo();        // _Z3foov
void foo(int);     // _Z3fooi
void foo(double);  // _Z3food

常见的类型编码：

类型	编码
void	v
int	i
double	d
char	c
long	l
指针	P

这里我们也可以用nm main_signal.o来查看

编译器如何解决这个问题？

生成机器码+留一个备注（重定位信息）

重定位表是啥：一张需要补地址的清单

总结一下，在汇编阶段编译器的行为：收集所有符号表->给所有符号分配最终地址->处理重定位的信息 而符号表表达了谁是谁，重定位信息表达了地址填哪

1.4. 链接阶段：`g++ main.o foo.o -o app`

编译器把多个.o文件（包括库文件.a/.so）拼成一个可执行文件或共享库：

符号解析：把main.o里未定义的符号去别的.o/.a/.so里找定义
地址分配和段合并： 把各个.text/.data合并，给每个符号分配最终地址
重定位： 把机器码/数据中”占位“的地址改成最终地址
处理库依赖：
- 静态库.a：把需要的目标文件成员抽取进行最终程序
- 动态库.so：记录依赖关系，运行时由动态装载器加载

命令演示

[vect@VM-0-11-centos link]$ g++ main.o foo.o -o app
[vect@VM-0-11-centos link]$ ./app
[vect@VM-0-11-centos link]$ ldd ./app	# 查看依赖的动态库
	linux-vdso.so.1 =>  (0x00007ffd751fe000)
	libstdc++.so.6 => /home/vect/.VimForCpp/vim/bundle/YCM.so/el7.x86_64/libstdc++.so.6 (0x00007ff731b8b000)
	libm.so.6 => /lib64/libm.so.6 (0x00007ff731889000)
	libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007ff731673000)
	libc.so.6 => /lib64/libc.so.6 (0x00007ff7312a5000)
	/lib64/ld-linux-x86-64.so.2 (0x00007ff731f0c000)

1.5. 把模板定义放到`.cpp`会发生什么？

add.h只写声明

// add.h
#pragma once

template <typename T>
T add(T a, T b);   // 只有声明，没有定义

add.cpp定义模板

// add.cpp
#include "add.h"

template <typename T>
T add(T a, T b) {
    return a + b;
}

// main.cpp
#include <iostream>
#include "add.h"

int main() {
    std::cout << add(1, 2) << std::endl;
    return 0;
}

编译每个cpp都成功了：

[vect@VM-0-11-centos template]$ g++ -c add.cpp -o add.o
[vect@VM-0-11-centos template]$ g++ -c main.cpp -o main.o

这里已经埋雷了

链接出错：

[vect@VM-0-11-centos template]$ g++ add.o main.o -o app
main.o: In function `main':
main.cpp:(.text+0xf): undefined reference to `int add<int>(int, int)'
collect2: error: ld returned 1 exit status

为什么会出错？

编译main.cpp发生了什么？

add(1,2);

编译器知道这是个模板
需要生成add<int>函数体
但在add.h里只看到声明，没有定义于是编译器只能假设将来有人实现add<int> 在mian.o里：符号表是U int add<int>(int, int)

编译add.cpp发生了什么？

[vect@VM-0-11-centos template]$ nm -C add.o
[vect@VM-0-11-centos template]$

符号表是空的！！！

在add.cpp里没有任何地方用到add<int>，编译器遵循模板哪里使用哪里实例化的原则

链接发生了什么？

文件	情况
main.o	我需要 add<int>
add.o	我没定义 add<int>

现在没人提供这个符号！！！

报错：undefined reference to int add<int>(int, int)

本质说明了：模板的实例化发生在编译期，而不是链接期

所以，怎么解决？

模板定义放在头文件
在add.cpp文件中显式实例化

2. 动态库和静态库

动态库：用的时候，程序只记住去哪里找，真正运行时再加载静态库：用的时候，把代码直接拷贝到程序里

我们还是用add这份代码，不要模板

2.1. 动态库

Linux下：.so为后缀的文件，本质是独立存在的二进制文件

怎么生成？

生成位置无关代码：g++ -fPIC add.cpp -o add.o -fPIC告诉编译器这段代码将来被共享
生成动态库：g++ -shared add.o -o libadd.so 生成了动态库：libadd.so
动态库链接：g++ main.cpp -L. -ladd -o app_dynamic -L.:在当前目录找库 -ladd：优先找libadd.so
验证依赖： ldd app_dynamic

完整代码：

[vect@VM-0-11-centos rep]$ g++ -fPIC -c add.cpp -o add.o
[vect@VM-0-11-centos rep]$ g++ -shared add.o -o libadd.so
[vect@VM-0-11-centos rep]$ g++ main.cpp -L. -ladd -o app_dynamic
[vect@VM-0-11-centos rep]$ g++ main.cpp -L. -ladd -o app_dynamic
[vect@VM-0-11-centos rep]$ ./app_dynamic
3
[vect@VM-0-11-centos rep]$ ldd app_dynamic
	linux-vdso.so.1 =>  (0x00007ffe6c5bd000)
	libadd.so (0x00007fdfcef90000)
	libstdc++.so.6 => /home/vect/.VimForCpp/vim/bundle/YCM.so/el7.x86_64/libstdc++.so.6 (0x00007fdfcec0f000)
	libm.so.6 => /lib64/libm.so.6 (0x00007fdfce90d000)
	libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007fdfce6f7000)
	libc.so.6 => /lib64/libc.so.6 (0x00007fdfce329000)
	/lib64/ld-linux-x86-64.so.2 (0x00007fdfcf192000)

动态库：编译时只记住地址，运行时再加载代码

2.2. 静态库

Linux下：.a为后缀的文件，本质是一堆.o文件的打包

怎么生成？

编译成目标文件：g++ -c add.cpp -o add.o 此时add.o里面有add的机器码，还没有生成程序
打包成静态库：ar rcs libadd.a add.o 现在有静态库：libadd.a
链接生成可执行程序：g++ main.cpp libadd.a -o app_static main.cpp用了add，libadd.a里刚好有add.o，直接把add.o复制进最终程序
查看依赖：ldd app_static 会发现没有libadd.a,其实代码已经拷贝到程序里了

完整代码：

[vect@VM-0-11-centos rep]$ g++ -c add.cpp -o add.o
[vect@VM-0-11-centos rep]$ ar rcs libadd.a add.o
[vect@VM-0-11-centos rep]$ g++ main.cpp libadd.a -o app_static
[vect@VM-0-11-centos rep]$ ./app_static
3
[vect@VM-0-11-centos rep]$ ldd app_static
	linux-vdso.so.1 =>  (0x00007ffd18faa000)
	libstdc++.so.6 => /home/vect/.VimForCpp/vim/bundle/YCM.so/el7.x86_64/libstdc++.so.6 (0x00007f51a6245000)
	libm.so.6 => /lib64/libm.so.6 (0x00007f51a5f43000)
	libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007f51a5d2d000)
	libc.so.6 => /lib64/libc.so.6 (0x00007f51a595f000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f51a65c6000)

静态库：编译时把代码拷贝到而可执行文件