深色模式
第 4 章:包含与导入:程序的第一行在做什么
本章承接第 3 章的输入输出:你已经会用
cout打印了,现在弄清程序开头那行#include <iostream>到底在做什么。它是后续章节使用更多标准库功能、以及把程序拆成多个文件的地基。
本章能学到什么
- 故意不写
#include,从报错中读懂它的作用 #include的本质:编译之前的"文本复制粘贴",并亲眼看一次粘贴结果- 尖括号
<>与双引号""的区别 - 头文件(.h)与源文件(.cpp)为什么分开:编译与链接两道工序
- 重复包含的后果与头文件保护符
- 四种常见报错的自查方法
- C++ 的
#include与 Python 的import全面对照
先制造一个困惑:不写会怎样
从第 0 章到现在,每个 C++ 程序的第一行都是同一句话:
cpp
#include <iostream>它看起来像一句咒语。很多教程只说"写上它,别问为什么"。写了一年代码的人里,也有不少说不清它到底干了什么。本章偏要问个明白。
问"一个东西有什么用",最可靠的办法是看看没有它会怎样。下面这个程序故意不写 #include:
cpp
// forget.cpp —— 故意不写 #include
int main() {
cout << "你好" << endl;
return 0;
}编译它:
text
$ g++ forget.cpp -o forget
forget.cpp: In function 'int main()':
forget.cpp:3:5: error: 'cout' was not declared in this scope报错信息翻译过来是:cout 这个名字没有声明过,编译器不认识它。
这个报错透露了一个重要事实:cout 不是 C++ 语言自带的词汇。它不像 int、return 那样是关键字。它只是某个人写在 iostream 这个文件里的一个普通名字,就像你家的东西放在你家的柜子里。#include <iostream> 的作用,就是把那个文件的内容拿过来,让编译器认识 cout。
#include 的本质:文本复制
#include 的工作简单得令人意外:把指定文件的全部内容,原样复制粘贴到这一行的位置。它不理解代码的含义,不会判断"需不需要",只会机械地粘贴。
这件事发生在编译之前。C++ 的编译流程里有一个打前站的工具叫预处理器:它先扫一遍源代码,把所有 # 开头的指令处理掉,#include 就是其中最重要的一条。预处理器处理完的"展开版"代码,才会交给编译器真正翻译。
空口无凭。做个实验亲眼看看:自己写一个头文件,再 include 它。
第一步,写 mymath.h:
cpp
// mymath.h —— 我们自己写的头文件
int add(int a, int b) {
return a + b;
}第二步,在同一个文件夹里写 main.cpp:
cpp
#include <iostream>
#include "mymath.h" // 双引号:先在当前文件夹里找
using namespace std;
int main() {
cout << add(3, 4) << endl;
return 0;
}编译运行:
text
$ g++ main.cpp -o main
$ ./main
7程序跑通了。main.cpp 里明明没有写 add 函数,为什么能调用?因为预处理器把 mymath.h 的内容粘贴了进来。
这个"粘贴"可以直接看到。给 g++ 加 -E 选项,意思是只做预处理、不编译,把展开结果打印出来:
text
$ g++ -E main.cpp输出的最后几行里,能清楚看到 add 函数的完整内容出现在 main 前面:
text
...(前面是 iostream 粘贴进来的内容)...
int add(int a, int b) {
return a + b;
}
...
int main() {
cout << add(3, 4) << endl;
return 0;
}所以 #include "mymath.h" 和你手动打开 mymath.h、全选、复制、粘贴进 main.cpp,效果一模一样。
顺便数一数粘贴的规模。把展开结果统计一下行数:
text
$ g++ -E main.cpp | wc -l结果是几万行(具体数字因编译器版本而异)。这几万行绝大部分来自 #include <iostream>——cout 就藏在这几万行里。每次写一个只有十行的程序,预处理器都在背后默默搬来一座图书馆。
尖括号 <> 与双引号 ""
为什么 iostream 用尖括号,mymath.h 用双引号?区别在于去哪里找文件。
| 写法 | 查找顺序 | 典型用途 |
|---|---|---|
#include <文件名> | 去编译器的系统目录找 | 标准库,如 <iostream>、<cmath> |
#include "文件名" | 先在当前文件夹找,找不到再去系统目录 | 自己写的头文件,如 "mymath.h" |
可以类比取快递:双引号是先看看家门口有没有,没有再去快递站;尖括号是跳过家门口,直接去快递站。
几个后面章节会陆续用到的标准库头文件,先混个眼熟:
| 头文件 | 提供的功能 |
|---|---|
<iostream> | 输入输出:cout、cin |
<cmath> | 数学函数:sqrt、pow、绝对值 |
<string> | 字符串类型 string |
这张表不需要背。用到哪个功能时,查一下它在哪个头文件里即可。
为什么 .h 和 .cpp 要分开
上面的实验把 add 函数的完整代码写进了 mymath.h。这能跑,但正规的 C++ 工程不这么干。头文件里通常只放声明——一句话告诉大家"有这样一个函数";函数的完整代码(定义)放在 .cpp 源文件里。
为什么要分开?先建立一个画面:C++ 从源代码到能运行的程序,要经过两道工序。
| 工序 | 工具 | 做什么 | 类比 |
|---|---|---|---|
| 编译 | 编译器 | 每个 .cpp 单独翻译成机器码半成品(.o 文件) | 每位厨师按菜谱做自己的菜 |
| 链接 | 链接器 | 把若干 .o 组装成一个完整程序 | 传菜员核对菜单,把菜配齐端上桌 |
现在用"菜谱与厨师"理解 .h 和 .cpp 的分工:
- 头文件 .h 是菜谱。它只写"本店供应宫保鸡丁",不写做法。任何想点这道菜的程序,只要 include 这份菜谱,就知道可以点、该报什么参数。
- 源文件 .cpp 是后厨。真正的做法写在这里,编译成半成品。
- 链接器是传菜员。main.cpp 点了
add这道菜,传菜员拿着点菜单去各个半成品里找。找到 mymath.o 里有add,就把它们组装在一起。找不到,就报"undefined reference"(找不到定义)。这个报错来自链接器,不是编译器。
为什么编译器只靠"菜谱"就敢放行?因为声明本身就是一种承诺:"这个函数存在,长这个样子,链接时你会找到它。"编译器相信这个承诺,先把 main.cpp 编译成半成品,把"找 add 的活"留给链接器。
完整走一遍。这次分三个文件:
cpp
// mymath.h —— 菜谱:只写声明
int add(int a, int b);cpp
// mymath.cpp —— 后厨:写完整做法
int add(int a, int b) {
return a + b;
}cpp
// main.cpp —— 点菜的人
#include <iostream>
#include "mymath.h"
using namespace std;
int main() {
cout << add(3, 4) << endl;
return 0;
}编译时把两个 .cpp 一起交给 g++:
text
$ g++ main.cpp mymath.cpp -o main
$ ./main
7分开的好处很实际:如果 add 的做法要改,只需重新编译 mymath.cpp 这一个文件,main.cpp 不用动。菜谱没变,点菜的人不用重新学。大型工程有成千上万个文件,全部重新编译可能要几小时,只编译改过的文件只要几秒。游戏公司、浏览器厂商天天靠这个机制节省时间。
重复包含的麻烦
文本复制有一个天然的问题:同一个头文件被粘贴两次,函数就定义了两遍,编译器会报错。
试试在 main.cpp 里写两行:
cpp
#include "mymath.h"
#include "mymath.h"如果 mymath.h 里放的是定义(像本章第一个实验那样),编译会报:
text
error: redefinition of 'int add(int, int)'"redefinition"意思是重复定义。同一个名字定义两次,编译器不知道该信哪份。
真实工程里很少故意写两行一样的 include,但会出现间接重复:a.h 包含了 c.h,b.h 也包含了 c.h,main.cpp 同时包含 a.h 和 b.h——c.h 就被粘贴了两遍。文件一多,这种间接重复几乎必然发生。
解决办法是给头文件戴上"防重复手环"。行业惯例写法:
cpp
// mymath.h —— 带保护符的标准写法
#ifndef MYMATH_H
#define MYMATH_H
int add(int a, int b);
#endif原理像景区检票:第一次粘贴时 MYMATH_H 这个"印章"没盖过,于是盖上它(#define),并放行中间的内容;第二次粘贴时印章已在手背上,#ifndef(如果没定义)判断不成立,整段内容被跳过。
如今多数编译器也支持一句更省事的写法,写在头文件第一行:
cpp
#pragma once意思是"这个文件只粘贴一次"。两种写法都常见,效果相同。
常见报错自查表
本章涉及四种经典报错。遇到时对照下表排查:
| 报错关键词 | 可能原因 | 怎么办 |
|---|---|---|
xxx was not declared | 忘了 #include 对应头文件 | 补上 include |
No such file or directory | 文件名写错,或 <> 与 "" 用错 | 检查文件名和括号 |
undefined reference to 'xxx' | 链接时缺少对应的 .cpp | 编译时把 .cpp 一起交给 g++ |
redefinition of 'xxx' | 头文件被重复包含 | 加头文件保护符 |
前两行是编译错误(菜名不认识),第三行是链接错误(菜没做),第四行也是编译错误(一道菜做了两遍)。分清报错来自哪道工序,排查就快得多。
用库函数验证数学
标准库不是抽象概念,它能立刻解决数学课上的问题。开平方、幂运算、绝对值,都在 <cmath> 里:
cpp
#include <iostream>
#include <cmath>
using namespace std;
int main() {
cout << sqrt(16) << endl; // 根号 16
cout << pow(2, 10) << endl; // 2 的 10 次方
cout << abs(-7) << endl; // 绝对值
return 0;
}text
4
1024
7对照数学式子:
头文件里还能放什么
本章的头文件只放了函数。实际工程里,头文件是"对外公告栏",常见的公告包括:
| 内容 | 例子 |
|---|---|
| 函数声明 | int add(int a, int b); |
| 常量 | const double PI = 3.14159; |
| 类型定义 | 后面章节会讲的结构体 |
判断标准很简单:别人使用你的代码时需要知道什么,就放什么。做法细节留在 .cpp 里,那是后厨的事。
为什么 C++ 不直接抄 Python 的模块
看完后面的对照表,一个自然的疑问是:既然模块系统好用,C++ 为什么不用?
答案是历史。#include 继承自 1972 年诞生的 C 语言。当年的计算机内存只有几十 KB,编译器必须一遍扫过源代码,没有余力维护"模块对象"这样的运行时结构。文本复制是那个年代最省资源的方案。
这个方案一路沿用下来,成了 C++ 生态的地基:全世界几十年的 C/C++ 代码都建立在头文件之上。改动地基意味着所有老代码都要重写,代价不可承受。所以 C++ 的选择是"打补丁":头文件保护符是补丁,2020 年 C++20 标准引入的真正模块系统是更大的补丁。
语言设计一旦发布就有了惯性。Python 诞生于 1991 年,比 C 晚了近二十年,起点就站在更充裕的硬件上。两门语言的差异,有一半是时代的差异。
Python 那边怎么做
Python 也有"用别人写好的代码"的需求,对应语句是 import math。但它和 #include 是两种完全不同的机制:#include 发生在编译之前,是死板的文本复制;import 发生在程序运行的时候,把模块加载成一个可以查看、可以操作的对象。Python 甚至自带缓存,同一个模块 import 两次也不会出问题,不需要保护符。
完整的对比实验(包括"故意不写 import 会怎样"、亲手写一个模块再导入)在姊妹册 《Python 从入门到精通》第 4 章,建议对照着读。
【跨语言对照】
本质问题:程序不可能什么功能都自己写。打印文字、开平方、生成随机数……这些通用功能由语言随附的代码库提供。两门语言要回答同一个问题:怎么把库里的代码"接"进自己的程序?
各自做法:
| 对照项 | C++ | Python |
|---|---|---|
| 写法 | #include <iostream> | import math |
| 发生时机 | 编译之前(预处理期) | 程序运行时 |
| 本质 | 文本复制粘贴 | 加载模块为对象 |
| 重复包含后果 | 编译错误,需头文件保护 | 无妨,模块只加载一次(缓存) |
| 自带代码库叫什么 | 标准库 + 头文件 | 标准库 + 模块/包 |
| 第三方库怎么来 | 手动编译/包管理器 | pip install |
同一个需求"算 16 的平方根",两边的等价代码:
cpp
#include <iostream>
#include <cmath> // 数学函数库
using namespace std;
int main() {
cout << sqrt(16) << endl;
return 0;
}python
import math # 数学模块
print(math.sqrt(16))两边输出一致:
text
4(Python 实际打印的是 4.0,开平方的结果是小数;小数与整数的区别在第 2 章讲过。)
为什么设计不一样:这要从两门语言的"性格"说起,见下一节。
设计哲学:简陋但可控 vs 灵活但有代价
#include 的机制可以说是"简陋"的:它不理解代码含义,只会复制粘贴。重复包含了会报错,还要程序员自己写保护符。这个方案继承自 1970 年代的 C 语言,当年机器内存只有几十 KB,最简单的方案才能跑得动。
但简陋有简陋的好处。第一,零成本:预处理在编译前完成,程序运行时完全感觉不到它的存在,机器码里没有一丝多余开销。第二,完全可控:粘贴了什么、粘贴了几次,用 g++ -E 一看便知,没有任何隐藏行为。这正是 C++ 的核心哲学——零开销:没用到的功能不花一分钱,写下的每一行都可以预测。
代价也很真实:几万行的粘贴让编译变慢,保护符靠人肉维持。C++ 直到 2020 年的 C++20 标准才引入真正的模块系统作为补课,可见这个"简陋"方案多么深入人心。
Python 的模块系统是语言的一等公民:模块是真实存在的对象,可以被查看、传递、动态加载。代价是启动时要花时间去查找、加载、执行模块代码。Python 选择牺牲一点启动速度,换取灵活和开发效率——这也是它写起来快的原因。
两种选择没有高下之分,只有目标不同:C++ 追求让机器跑得极致,Python 追求让人写得痛快。
动手实验
- 把本章第一个实验改成减法:写 mymath.h 提供
int sub(int a, int b),main.cpp 调用它计算sub(10, 4),预期输出 6。然后用g++ -E main.cpp验证文本复制。
💡 查看答案
cpp
// mymath.h
#ifndef MYMATH_H
#define MYMATH_H
int sub(int a, int b) {
return a - b;
}
#endifcpp
// main.cpp
#include <iostream>
#include "mymath.h"
using namespace std;
int main() {
cout << sub(10, 4) << endl;
return 0;
}text
$ g++ main.cpp -o main
$ ./main
6- 故意制造一次链接错误:把"三个文件"那一节的程序只编译
g++ main.cpp -o main(不带 mymath.cpp),观察报错。它是编译错误还是链接错误?
💡 查看答案
报错类似 undefined reference to 'add(int, int)'。这是链接错误:编译阶段 main.cpp 从 mymath.h 的声明知道 add 存在,编译通过;但链接时找不到 add 的定义。传菜员拿着点菜单,发现后厨没做这道菜。
- 给 main.cpp 写两行
#include "mymath.h",分别用"不带保护符、且含有函数定义的头文件"和"带保护符的头文件"编译,对比结果。
💡 查看答案
不带保护符时报 redefinition 错误;加了 #ifndef/#define/#endif 或 #pragma once 后编译通过,因为第二次粘贴的内容被跳过。
