头文件在 C++ 里“看似只是复制粘贴”，实则承担了 5 大类刚性任务；下面每类给一段最小可跑代码，一眼就能看出“如果没有头文件，得写多脏”。
- 提供声明——让翻译单元通过编译
场景：A.cpp 想调用 B.cpp 里定义的函数，编译 A 时只拿到声明即可，不必把 B 整段粘过来。
例子
//-------------- math_tools.hpp --------------
#pragma once
double add(double, double); // 声明
//-------------- math_tools.cpp --------------
double add(double a, double b) { return a + b; }
//-------------- main.cpp --------------------
#include "math_tools.hpp"
#include <iostream>
int main(){
std::cout << add(3, 4); // 5
}
去掉头文件，就得把 add 的完整定义抄进 main.cpp，失去分离编译的意义。
2 暴露类 / 模板——实现接口与实现分离
场景：库只暴露“怎么用”，隐藏“怎么干”。
例子
//------------- circle.hpp ------------------
#pragma once
class Circle{ // 公开接口
public:
Circle(double r);
double area() const;
private:
double radius_;
};
//------------- circle.cpp ------------------
#include "circle.hpp"
#include <numbers>
Circle::Circle(double r): radius_(r) {}
double Circle::area() const{
return std::numbers::pi * radius_ * radius_;
}
//------------- main.cpp --------------------
#include "circle.hpp"
#include <iostream>
int main(){
Circle c(1.0);
std::cout << c.area(); // 3.14159...
}
编译 main.cpp 只需知道类的大小和调用约定，具体算法在 circle.cpp 里改不动主程序。
3 模板 & 内联代码——“实现也必须可见”
场景：模板在实例化时需要完整定义，内联函数同理。
例子
//-------------- utils.hpp ------------------
#pragma once
template<class T>
T max(T a, T b){ return (a > b) ? a : b; }
inline int sqr(int x){ return x * x; }
//-------------- main.cpp -------------------
#include "utils.hpp"
#include <iostream>
int main(){
std::cout << max(3.5, 2.7) << '\n'; // 3.5
std::cout << sqr(5) << '\n'; // 25
}
若把模板定义放到 .cpp，其他翻译单元实例化 max<double> 时会报“未定义”。
4 宏、常量、条件编译——跨文件共享“编译期开关”
场景：同一套源码，调试/发布、不同平台用不同宏。
例子
//-------------- config.hpp -----------------
#pragma once
#define VERSION 202506L
#define DEBUG_LOG(x) do{ if constexpr(DEBUG) std::cerr << x << '\n'; }while(0)
constexpr bool DEBUG = true;
//-------------- main.cpp -------------------
#include "config.hpp"
#include <iostream>
int main(){
DEBUG_LOG("debug mode on");
std::cout << "ver " << VERSION;
}
改一行宏，全体翻译单元同时生效，无需手动改 N 个 .cpp。
5 前向声明 + 包含守卫——减少重复解析，加速编译
场景：大型工程里 A 用 B、B 用 C，若直接 #include "b.cpp" 会无限递归且爆炸。
例子
//-------------- foo_fwd.hpp -------------- // 仅前向声明
#pragma once
class Foo; // 不完整类型
void process(const Foo&); // 接受引用/指针即可
//-------------- foo.hpp ------------------- // 完整定义
#pragma once
#include "foo_fwd.hpp"
class Foo{ int value{}; };
void process(const Foo& f){ /*...*/ }
//-------------- main.cpp -------------------
#include "foo.hpp"
int main(){ Foo f; process(f); }
通过“守卫宏” #pragma once（或传统 #ifndef）保证同一头文件在一个翻译单元里只展开一次；前向声明让“仅需指针/引用”的地方不必拉入完整定义，显著降低编译量。
一句话总结
头文件 = 跨翻译单元的“公共契约”：
声明函数/类/模板→让编译通过，
暴露接口→隐藏实现，
共享宏与常量→统一行为，
前向声明+守卫→加速构建。
没有它，C++ 的“分离编译”模型就彻底崩塌。
