cpp 复制代码

-- 整体流程
C++ 源文件 (.cpp)
   ↓  预处理（展开头文件、宏替换等）
预处理后的代码 (.i)
   ↓  编译（编译器）
汇编代码 (.s)
   ↓  汇编（汇编器）
目标文件 (.o / .obj)
   ↓  链接（连接器）
最终可执行文件（如 a.out / exe）

（一）预处理

C++ 的 预处理阶段（Preprocessing） 是整个编译过程的第一步，它在真正编译代码前处理以 # 开头的指令 ，生成一个中间文件（通常扩展名为 .i），供后续编译器编译。简单理解：预处理阶段就像在编译之前对源码进行"文本替换和展开"的处理器。

预处理器主要做了什么？

1. 头文件展开：`#include`

cpp 复制代码

#include <iostream>
#include "myutils.h"

被替换为头文件的全部内容（递归展开）。

2. 宏替换：`#define`

cpp 复制代码

#define PI 3.14
std::cout << PI;  // → std::cout << 3.14;

所有出现 PI 的地方都被替换为 3.14。

3. 条件编译：

#ifdef / #ifndef / #if / #else / #endif

cpp 复制代码

#ifdef DEBUG
    std::cout << "Debugging" << std::endl;
#endif

如果定义了 DEBUG，这段代码会被保留；否则会被忽略。

4. 删除注释

（// 和 /\* \*/）

预处理阶段会移除所有注释，不再传给编译器。

5. 宏函数展开：

cpp 复制代码

#define SQUARE(x) ((x)*(x))
SQUARE(3 + 1)  // → ((3 + 1)*(3 + 1)) → 16

注意宏替换是纯文本替换，没有类型检查。

6. 错误指令处理：`#error`

cpp 复制代码

#ifndef PLATFORM
#error "PLATFORM not defined!"
#endif

如果没有定义 PLATFORM，预处理器报错并停止编译。

如何查看预处理结果？

使用 g++ 命令：

bash 复制代码

g++ -E main.cpp -o main.i

main.i 文件就是预处理之后的纯文本 C++ 代码；
可用于查看头文件展开、宏替换等效果。

例子：

源码：

cpp 复制代码

// main.cpp
#include <iostream>
#define PI 3.14

int main() {
    std::cout << PI << std::endl;
    return 0;
}

预处理后：

cpp 复制代码

// 展开为 iostream 的实际内容...
int main() {
    std::cout << 3.14 << std::endl;
    return 0;
}

（二）编译-汇编

1. 编译（Compile）：C++ → 汇编代码（`.s`）

编译器的任务：

分析源代码：词法分析、语法分析、语义分析；
中间表示（IR）生成：构建抽象语法树（AST）和 LLVM IR 等中间代码；
优化：常量折叠、循环展开、函数内联、死代码消除等；
生成汇编代码：将优化后的中间代码生成目标 CPU 的汇编语言。

示例命令：

bash 复制代码

g++ -S main.cpp -o main.s

输出示例（x86 汇编）：

asm 复制代码

main:
    push    rbp
    mov     edi, OFFSET FLAT:.LC0
    call    puts
    pop     rbp
    ret

2. 汇编（Assemble）：汇编代码 → 目标文件（`.o`）

汇编器的任务：

将汇编语言转成二进制机器码（目标代码）；
构建符号表、指令地址映射等；
输出 .o 文件（或 .obj）。

bash 复制代码

as main.s -o main.o   # 或由 g++ 自动完成

这个 .o 文件：

是一段不能单独运行的机器代码；
包含未解析的符号（如对 printf 的引用）；
需要链接阶段才能成为可执行程序。

3. 编译器 vs 汇编器对比

步骤	输入	输出	工具	作用
编译	`.cpp` / `.i`	`.s`（汇编）	编译器（如 `g++ -S`）	将 C++ 源码转换为汇编语言
汇编	`.s`	`.o`（目标文件）	汇编器（如 `as`）	将汇编语言转换为机器码

4. 例子：代码到机器

cpp 复制代码

int add(int a, int b) {
    return a + b;
}

经过编译 → 生成汇编：

asm 复制代码

add:
    mov eax, edi
    add eax, esi
    ret

再经过汇编器 → 生成 .o 文件（二进制形式）：

汇编复制代码

b8 01 00 00 00    ; mov eax, 1
01 f0             ; add eax, esi
c3                ; ret

.s 是汇编语言（人类可读）
.o 是机器语言（二进制，CPU 可执行，但不能独立运行）
最后再由链接器 ld 把多个 .o 文件合成完整程序

5. 编译单元

在 C++ 中，编译单元（Translation Unit） 是编译器处理的最小单位，理解它对于掌握 C++ 的编译过程、头文件组织、链接等都非常重要。

编译单元是什么？

一个编译单元就是一个源文件（.cpp）加上它所包含的所有头文件，经过预处理后的完整代码集合。

也就是说：

复制代码

编译单元 = 源文件 + 源文件 `#include` 的头文件（递归展开后）

然后，编译器会单独对每个编译单元生成一个 .o 或 .obj 目标文件。

例子：

假设我们有以下文件：

cpp 复制代码

// math_utils.h
#pragma once
int add(int a, int b);

// math_utils.cpp
#include "math_utils.h"
int add(int a, int b) {
    return a + b;
}

// main.cpp
#include "math_utils.h"
#include <iostream>
int main() {
    std::cout << add(3, 4) << std::endl;
    return 0;
}

这个程序两个编译单元：

math_utils.cpp（+ 它包含的 math_utils.h） → 编译单元 A
main.cpp（+ 它包含的 math_utils.h 和 <iostream>） → 编译单元 B

每个编译单元独立编译生成 .o 文件：

bash 复制代码

g++ -c math_utils.cpp -o math_utils.o   # 编译单元 A
g++ -c main.cpp -o main.o               # 编译单元 B

最后再链接：

bash 复制代码

g++ main.o math_utils.o -o program

问题	关系到编译单元的理解
❓ 为什么函数定义不能写在头文件中？	因为头文件会被多个 `.cpp` 包含，会重复定义，导致链接错误
❓ 为什么加 `inline` 可以解决重复定义？	编译器会允许多份相同定义，只要完全一致
❓ 静态变量/函数的作用域？	`static` 限定在当前编译单元可见
❓ 多文件项目如何组织？	每个 `.cpp` 独立编译，头文件共享声明

6. 防止头文件被重复包含

如果一个头文件在同一个编译单元中被重复包含 （即被多个地方 #include，或者被间接多次 #include），但没有使用头文件保护机制 （如 #pragma once 或 #ifndef/#define），将会导致 编译错误或潜在的奇怪行为。

重复包含会发生什么后果？

头文件中包含了函数定义 、变量定义 、结构体定义等。

1. 函数重复定义

cpp 复制代码

// mymath.h
int add(int a, int b) { return a + b; }  // 这是一个定义，不只是声明
// main.cpp
#include "mymath.h"
#include "mymath.h"  // 重复包含

int main() {
    return add(1, 2);
}

编译错误：

复制代码

error: redefinition of 'int add(int, int)'

因为预处理后，add 函数体出现了两次。

2. 结构体/类重复定义

cpp 复制代码

// point.h
struct Point {
    int x, y;
};
#include "point.h"
#include "point.h"

会导致：

复制代码

error: redefinition of 'struct Point'

3. 全局变量重复定义

cpp 复制代码

// globals.h
int global_value = 42;

多个 .cpp 文件都 #include "globals.h"，就会有多个 global_value，导致链接错误：

复制代码

multiple definition of `global_value`

注意：声明不会导致重复定义！

头文件中如果只写函数声明或类前向声明，不会出错：

cpp 复制代码

// safe.h
int add(int a, int b);  // 只是声明，不是定义

7. 如何避免重复包含？

在 C++ 中，为了防止 头文件被重复包含 （导致编译错误或冗余），我们通常使用以下两种方式实现**"头文件保护"**：

方法一：`#pragma once`（推荐）

cpp 复制代码

// math_utils.h
#pragma once

int add(int a, int b);

原理：

#pragma once 是一种编译器指令，告诉编译器：这个文件只编译一次。
多数现代编译器（如 GCC、Clang、MSVC）都支持它。

优点：

简洁易读；
不易出错（不用手动写宏名）；
编译器处理更高效（文件路径作为 key，不需字符串比较）。

方法二：传统的 include guard（兼容性最强）

cpp 复制代码

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);

#endif // MATH_UTILS_H

原理：

利用宏定义，如果 MATH_UTILS_H 没被定义，就定义它并包含内容。
如果文件被再次包含，由于宏已定义，内容就不会重复编译。

优点：

100% 兼容所有 C/C++ 编译器 （包括老旧的或不支持 #pragma once 的编译器）。

选择建议：

条件	推荐使用
使用现代编译器（如 GCC/Clang/MSVC）	`#pragma once`
追求最大兼容性（跨平台旧编译器）	`#ifndef` 宏守卫

（三）链接

链接（Linking ）是 C++ 编译流程的最后一个阶段，其作用是将多个目标文件（.o）和库文件 合并成一个可执行文件，并解决它们之间的符号引用（比如函数、变量的调用与定义）。

1、链接的作用

总结一句话：

链接的作用是把多个"碎片化的目标文件"拼接成一个完整可执行程序，并解决符号引用问题。

具体功能包括：

功能	举例说明
符号解析（Symbol Resolution）	把 `main.cpp` 中调用的 `add()` 对应到 `math_utils.cpp` 里的实现
地址重定位（Relocation）	确定每个函数/变量在内存中的最终位置
合并多个目标文件/库文件	多个 `.o` 文件和 `.a/.so` 库合并为可执行文件
处理静态库和动态库的引用	如链接 `libm.a` 或 `libm.so`（数学库）

2、常见链接问题（非常重要）

undefined reference（最常见错误）

原因：声明了某个函数/变量，但没有定义（或链接不到定义）。

cpp 复制代码

// main.cpp
void foo();  // 声明
int main() {
    foo();   // 链接时找不到定义就报错
}

报错：

复制代码

undefined reference to `foo()`

原因：

忘记实现
实现在另一个 .cpp 但没参与链接
静态库/动态库没链接进来（如 -lm、-lpthread）

multiple definition（重复定义）

原因：某函数或变量在多个 .o 文件中都定义了一遍。

比如：

cpp 复制代码

// a.h
int x = 5;  // 这是定义，不是声明！
// a.cpp 和 b.cpp 都包含了 a.h → 链接时重复定义 x

🛠 解决办法：

用 extern int x; 声明
真正的 int x = 5; 放在 .cpp 文件中
或用 inline 修饰函数定义、或使用 static 局部化作用域

重复符号但未链接失败（静态变量或静态函数）

如果你写了 static void helper()，哪怕在多个文件中重复，也不会冲突。

原因：static 修饰的函数/变量只在当前编译单元可见，不参与全局链接。

链接顺序错误（特别是在 Linux 下）

bash 复制代码

g++ main.o -lmylib

和

bash 复制代码

g++ -lmylib main.o  ❌

GNU LD 是从左往右解析依赖的，如果你的库在左边但 main.o 中引用的符号在右边，它会找不到。

3、静态链接 vs 动态链接

类型	描述	优点	缺点
静态链接 `.a`	编译时复制代码进可执行文件	运行时独立，不需外部依赖	程序体积大
动态链接 `.so`	编译时只记录库位置，运行时加载	程序小，可更新库	运行依赖外部 `.so`

4、常用链接参数（GCC）

参数	含义
`-c`	只编译，不链接（生成 `.o`）
`-o output`	指定输出文件名
`-l<name>`	链接库（如 `-lm` 表示链接 libm.so 或 libm.a）
`-L<path>`	指定库搜索路径
`-static`	强制静态链接
`-shared`	生成动态库 `.so`
`-Wl,-rpath=...`	设置动态库运行时路径

（四）ODR原则

ODR（One Definition Rule，唯一定义规则） 是 C++ 的一个核心规则，确保程序的链接阶段行为一致、确定。它规定了变量、函数、类等在整个程序中只能有一个定义，否则会导致链接错误或未定义行为。

1、ODR 是什么？

One Definition Rule（唯一定义规则）：

在一个程序中，每个变量、函数、类、模板、枚举等 都必须最多只有一个定义 ，而可以有多个声明。这个"唯一定义"必须在所有使用它的翻译单元中一致。

2、声明 vs 定义

声明（declaration）：告诉编译器"有这个东西"，但不提供实现。
定义（definition）：提供了完整内容或内存分配。

cpp 复制代码

extern int x;      // 声明
int x = 42;        // 定义

3、ODR 的几种典型应用

1. 普通变量

cpp 复制代码

// config.hpp
const int SIZE = 100;

如果这个头文件被多个 .cpp 文件包含，会违反 ODR！

修复方法：

使用 inline const（C++17）：
cpp 复制代码
```
inline const int SIZE = 100;
```

或使用 extern + .cpp 定义：

cpp 复制代码

// config.hpp
extern const int SIZE;

// config.cpp
const int SIZE = 100;

2. 函数定义

cpp 复制代码

// utils.hpp
int add(int a, int b) {
    return a + b;
}

多个 .cpp 包含此头文件，会导致链接器错误：multiple definition of add

✔️ 正确做法：加 inline 或将定义放在 .cpp 中。

3. 类成员函数

cpp 复制代码

class A {
public:
    void sayHi() {
        std::cout << "Hi" << std::endl;
    }
};

类内定义的成员函数是 自动 inline 的，所以不违反 ODR，可以放头文件中。

4. 模板

模板必须放在头文件中，因为它在实例化时才生成代码，必须可见定义。

cpp 复制代码

template<typename T>
T square(T x) {
    return x * x;
}

✔️ 合法：定义写在 .hpp 中

❌ 不合法：只写声明在 .hpp，把定义放在 .cpp

5. 同名函数/类在不同文件中重复定义

cpp 复制代码

// file1.cpp
int foo() { return 1; }

// file2.cpp
int foo() { return 2; }

💥 链接时报错：multiple definition of foo

4、什么时候 ODR 不适用？

在函数体内部的局部变量，不参与 ODR 检查。
内联函数、模板实例、类内函数默认支持多份定义，只要内容一致即可。

5、如何避免 ODR 问题

情况	正确做法
多文件共享变量	使用 `extern` + 单一 `.cpp` 定义
头文件中定义变量	使用 `inline`（C++17）
头文件中定义函数	使用 `inline` 或函数模板
模板定义	保持全部写在头文件
类成员函数类内定义	默认 `inline`，合法
非模板函数定义	建议写在 `.cpp` 中

ODR 确保了整个程序中对每个实体的实现只有一个真实定义，防止了链接冲突和运行期不一致的问题，是编译器链接阶段的一道安全网。

（五）inline的作用

inline 是 C++ 中一个重要的关键字，最初用于建议编译器将函数的调用"内联展开"（即把函数体直接替换到调用处），以减少函数调用的开销。

但随着 C++ 的发展，inline 的用途逐渐扩展，尤其在头文件中定义函数和变量时变得非常重要。

1、`inline` 的主要作用

建议编译器内联展开函数（性能优化）

cpp 复制代码

inline int add(int a, int b) {
    return a + b;
}

🔹 编译器可能会 将 add(2, 3) 替换为 2 + 3，省掉函数调用开销（尤其是小函数）。

⚠️ 注意：是否真正内联是编译器的决定，inline 只是"建议"。

允许函数或变量定义出现在多个翻译单元中（核心用途）

这是现代 C++ 中更重要的用途！

举例：头文件中定义函数或变量

cpp 复制代码

// math.hpp
inline int square(int x) {
    return x * x;
}

如果没有 inline，多个 .cpp 文件包含 math.hpp，会导致 ODR（One Definition Rule）冲突；
加上 inline，编译器允许多个定义存在，只要内容一致。

从 C++17 开始，`inline` 还可用于变量

允许变量的定义出现在多个翻译单元中而不违反 One Definition Rule（ODR）

cpp 复制代码

// config.hpp
inline const int BUFFER_SIZE = 1024;

这样你就可以在多个 .cpp 中 #include "config.hpp" 而不会重复定义冲突。

2、使用场景总结

场景	说明
小函数性能优化	用 `inline` 建议内联展开，避免调用开销（但现代编译器可自动优化）
头文件中定义函数	必须加 `inline`，否则多文件包含会重复定义，链接错误
头文件中定义 `const` 变量	必须加 `inline`（C++17 之后），或使用 `extern` 声明
模板函数/类	默认就是 `inline`，不需要显式写

3、和 `static` 的区别（重要！）

inline：多个翻译单元共享一个定义
static：每个翻译单元都有自己的副本（内部链接）

cpp 复制代码

// inline 版本：多个 .cpp 文件共享
inline int globalFunc() { return 1; }

// static 版本：每个 .cpp 文件都有一份
static int globalFunc() { return 1; }

4、ODR（One Definition Rule）相关说明

在 C++ 中，如果一个函数或变量在多个 .cpp 文件中定义且没有 inline 或 static 修饰，就会违反 ODR，导致链接错误。

使用 inline 是合法解决方案，允许在多个编译单元中拥有同一实体的定义。

5、什么时候不需要 `inline`

自动隐式 inline 的**，这意味着它们**可以也应该直接定义在头文件中**，不会违反 One Definition Rule（ODR），也不会导致链接错误。

函数模板 ：自动隐式 inline
类内定义的成员函数 ：自动隐式 inline

cpp 复制代码

class A {
public:
    int getX() { return x; }  // 自动是 inline
};

（六）多文件项目的基本结构

在 C++ 中，多文件项目的组织方式直接关系到模块化、可维护性、可复用性 ，同时影响编译速度和链接行为。下面从项目结构、文件职责、如何编译链接、以及实用建议四个方面详细说明：

假设我们写一个简单的数学库项目：

复制代码

MyProject/
├── main.cpp              // 主程序入口
├── math/
│   ├── math_utils.h      // 函数声明（头文件）
│   └── math_utils.cpp    // 函数定义（实现文件）
├── string/
│   ├── string_utils.h
│   └── string_utils.cpp
└── Makefile              // 或 CMakeLists.txt

1、每类文件的职责

文件类型	后缀	作用
源文件	`.cpp`	写具体的实现（函数体、类定义等）
头文件	`.h` / `.hpp`	放函数声明、类定义、宏、模板等，不写函数体（除非是 `inline` 或模板）
实现文件	`.cpp`	通常和同名 `.h` 配对
主程序入口	`main.cpp`	`int main()` 所在文件
构建脚本	`Makefile` / `CMakeLists.txt`	编译自动化

2、函数/类的声明与定义分离

math_utils.h（声明）

cpp 复制代码

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int subtract(int a, int b);

#endif

math_utils.cpp（定义）

cpp 复制代码

#include "math_utils.h"

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

main.cpp

cpp 复制代码

#include <iostream>
#include "math/math_utils.h"

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

3、如何编译和链接

手动编译方式（GCC/Clang）：

bash 复制代码

g++ -c math/math_utils.cpp -o math_utils.o
g++ -c main.cpp -o main.o
g++ math_utils.o main.o -o myprogram

一步完成：

bash 复制代码

g++ main.cpp math/math_utils.cpp -o myprogram

4、使用 Makefile（推荐）

makefile 复制代码

# Makefile
CXX = g++
CXXFLAGS = -std=c++11 -Wall
OBJECTS = main.o math/math_utils.o string/string_utils.o

myprogram: $(OBJECTS)
	$(CXX) $(OBJECTS) -o myprogram

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

clean:
	rm -f *.o */*.o myprogram

使用：

bash 复制代码

make
make clean

5、项目组织建议

建议	说明
头文件保护	每个 `.h` 文件用 `#pragma once` 或 `#ifndef`
命名空间	避免函数/类名冲突
按模块分目录	如 `math/`、`io/`、`network/`
源文件不互相 include	`.cpp` 只包含 `.h`，不要包含别的 `.cpp`
头文件只写声明，不写定义	除非是模板或 `inline` 函数
类定义放头文件，类成员函数实现放 `.cpp` 文件	分离职责
用构建工具	`make` 或 `cmake` 简化构建过程
避免全局变量	用类封装或传参

（七）头文件和源文件

（一）所有函数和变量都写在头文件中

所有函数和变量都写在头文件中 （即：函数和变量的定义都在头文件中）就是：不使用 .cpp 文件 ，所有的函数实现、全局变量定义、类定义等都直接写在 .h 或 .hpp 文件中。这是一种不推荐的做法，但在某些特殊场景下会被使用。

示例：

cpp 复制代码

// myheader.h

int globalVar = 0;  // 全局变量定义

void foo() {
    // 函数定义
}

class MyClass {
public:
    void bar() {
        // 类成员函数内联定义
    }
};

存在的问题（主要缺点）

1. 违反 One Definition Rule (ODR)

C++ 要求每个非 inline 的函数或变量在整个程序中只能有一个定义。
如果你在多个 .cpp 文件中 #include "myheader.h"，那么 globalVar 和 foo() 都会被重复定义。
这会导致链接错误（multiple definition error）。

示例报错：

复制代码

duplicate symbol _globalVar in:
    main.o
    other.o
ld: 1 duplicate symbol for architecture x86_64

2. 全局变量重复定义

普通全局变量不能在头文件中定义多次。
必须使用 extern 声明 + .cpp 中定义的方式。

3. 编译速度变慢

所有包含这个头文件的 .cpp 文件都会包含完整的实现代码。
修改一次头文件，所有依赖它的 .cpp 文件都要重新编译。

4. 难以维护与协作

头文件应该只暴露接口，而不是实现。
把实现也放在头文件中，破坏了模块化设计原则，不利于团队协作。

可以接受的情况（特殊情况）

虽然一般不推荐，但以下几种情况是可以在头文件中写定义的：

1. 模板函数/类

cpp 复制代码

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

模板必须在头文件中定义，因为编译器需要在使用时看到完整定义。

2. inline 函数

cpp 复制代码

inline void bar() {
    // ...
}

inline 关键字允许函数在多个翻译单元中出现。

3. constexpr 变量

cpp 复制代码

constexpr int MaxValue = 100;

constexpr 是隐式 inline 的。

4. static const 整型常量

cpp 复制代码

class MyClass {
public:
    static const int Value = 42;
};

（二）更规范的写法

如果你希望让函数和变量都在一个文件中管理，可以考虑以下做法：

1.使用单个 `.cpp` 文件 + 对应头文件

cpp 复制代码

// mylib.h
#ifndef MYLIB_H
#define MYLIB_H

extern int globalVar;
void foo();

#endif

cpp 复制代码

// mylib.cpp
#include "mylib.h"

int globalVar = 0;

void foo() {
    // 实现
}

2.使用静态库或动态库

将多个 .cpp 编译为 .a 或 .dll，然后通过头文件调用。

总结

写法	是否推荐	说明
所有函数和变量都写在头文件中	❌ 不推荐	容易导致链接错误、结构混乱
模板、inline 函数、constexpr 等写在头文件中	✅ 推荐	合理合法，符合标准
函数声明在头文件，定义在 `.cpp` 文件	✅ 强烈推荐	最佳实践，适合项目开发

🎯 头文件只放：

类定义
函数声明
extern 全局变量声明
inline / constexpr / template 函数定义

🎯 源文件放：

函数实现
全局变量定义
静态变量定义

这样可以保证代码清晰、可维护、可扩展，适用于各种规模的项目。

c++ 预处理 编译 链接 文件组织形式

（一）预处理

预处理器主要做了什么？

1. 头文件展开：#include

2. 宏替换：#define

3. 条件编译：

4. 删除注释

5. 宏函数展开：

6. 错误指令处理：#error

如何查看预处理结果？

例子：

源码：

预处理后：

（二）编译-汇编

1. 编译（Compile）：C++ → 汇编代码（.s）

编译器的任务：

示例命令：

输出示例（x86 汇编）：

2. 汇编（Assemble）：汇编代码 → 目标文件（.o）

汇编器的任务：

3. 编译器 vs 汇编器对比

4. 例子：代码到机器

5. 编译单元

编译单元是什么？

例子：

6. 防止头文件被重复包含

重复包含会发生什么后果？

1. 函数重复定义

2. 结构体/类重复定义

3. 全局变量重复定义

注意：声明不会导致重复定义！

7. 如何避免重复包含？

方法一：#pragma once（推荐）

方法二：传统的 include guard（兼容性最强）

（三）链接

1、链接的作用

具体功能包括：

2、常见链接问题（非常重要）

undefined reference（最常见错误）

multiple definition（重复定义）

重复符号但未链接失败（静态变量或静态函数）

链接顺序错误（特别是在 Linux 下）

3、静态链接 vs 动态链接

4、常用链接参数（GCC）

（四）ODR原则

1、ODR 是什么？

2、声明 vs 定义

3、ODR 的几种典型应用

1. 普通变量

2. 函数定义

3. 类成员函数

4. 模板

5. 同名函数/类在不同文件中重复定义

4、什么时候 ODR 不适用？

5、如何避免 ODR 问题

（五）inline的作用

1、inline 的主要作用

建议编译器内联展开函数（性能优化）

允许函数或变量定义出现在多个翻译单元中（核心用途）

从 C++17 开始，inline 还可用于变量

2、使用场景总结

3、和 static 的区别（重要！）

4、ODR（One Definition Rule）相关说明

5、什么时候不需要 inline

（六）多文件项目的基本结构

1、每类文件的职责

2、函数/类的声明与定义分离

math_utils.h（声明）

math_utils.cpp（定义）

main.cpp

3、如何编译和链接

手动编译方式（GCC/Clang）：

一步完成：

4、使用 Makefile（推荐）

5、项目组织建议

（七）头文件和源文件

（一）所有函数和变量都写在头文件中

示例：

存在的问题（主要缺点）

1. 违反 One Definition Rule (ODR)

c++ 预处理编译链接文件组织形式

1. 头文件展开：`#include`

2. 宏替换：`#define`

6. 错误指令处理：`#error`

1. 编译（Compile）：C++ → 汇编代码（`.s`）

2. 汇编（Assemble）：汇编代码 → 目标文件（`.o`）

方法一：`#pragma once`（推荐）

1、`inline` 的主要作用

从 C++17 开始，`inline` 还可用于变量

3、和 `static` 的区别（重要！）

5、什么时候不需要 `inline`

1.使用单个 `.cpp` 文件 + 对应头文件