26 五月 2025
C++ 生态系统正在经历数十年来最深刻的变革，它从根本上重塑了代码的组织和编译方式。多年来，开发者一直与 #include 机制的局限性作斗争——其编译速度缓慢、宏污染普遍以及缺乏适当的封装。这些基于预处理器的方法固有的缺陷限制了 C++ 在大规模开发中的潜力，迫使工程师们采用复杂的变通方案和构建系统。
C++ 20 模块作为应对这些长期挑战的全面解决方案应运而生，它代表了自语言诞生以来 C++ 代码组织上的首次重大范式转变。通过用结构化的二进制接口取代文本包含，模块在编译速度、代码隔离和接口清晰度方面提供了变革性的改进。这不仅仅是增量改进，而是解决 C++ 程序构建架构本身的根本性变化。
传统的头文件模型对现代 C++ 开发施加了四个基本限制：
C++ 模块直接应对这些挑战。它们被编译一次为二进制表示，然后编译器可以导入并以比基于文本的头文件显著更快的速度处理。这种代码转换大大减少了编译期间的冗余工作。模块还严格控制可见性，只导出明确标记的内容，从而防止宏污染并强制执行更强的封装。未明确导出或导入的名称和宏保持模块私有，从而提高代码隔离性。
理解基本语法是有效使用 C++ 模块进行编程的基础。模块定义通常涉及一个声明模块导出了哪些内容的接口单元，以及提供定义的实现单元。
考虑一个简单的 C++ 数学模块示例：
1. 模块接口单元 (math.ixx)
// math.ixx - 'math' 模块的主接口单元
export module math;
// 导出的函数声明
export int add(int a, int b);
export int multiply(int a, int b);
// 内部辅助函数，未导出
int subtract_internal(int a, int b);
在这里，export module math; 声明此文件是名为 math 的模块的主接口。add 和 multiply 前的 export 关键字表示这些函数是模块公共接口的一部分，可供其他导入 math 的翻译单元访问。subtract_internal 函数，没有 export，则保留为模块私有。
2. 模块实现单元 (math.cpp)
// math.cpp - 'math' 模块的实现单元
module math; // 将此文件与 'math' 模块关联
// 导出函数的定义
int add(int a, int b) {
return a + b;
}
int multiply(int a, int b) {
return a * b;
}
// 内部辅助函数的定义
int subtract_internal(int a, int b) {
return a - b;
}
此文件以 module math; 开头，将其链接到 math 模块。它包含 math.ixx 中声明的函数的定义。请注意，实现文件在其模块声明中不使用 export。
3. 使用模块 (main.cpp)
// main.cpp - 使用 'math' 模块
import math; // 导入 'math' 模块
#include <iostream> // 用于控制台输出
int main() {
int sum = add(10, 5); // 调用导出的函数
int product = multiply(10, 5); // 调用导出的函数
std::cout << "Sum: " << sum << std::endl;
std::cout << "Product: " << product << std::endl;
// int difference = subtract_internal(10, 5); // 错误：subtract_internal 未导出
return 0;
}
在 main.cpp 中，import math; 使 math 模块中导出的声明可用。add 和 multiply 可以直接使用，而 subtract_internal 仍然不可访问，这证明了模块的强封装性。
这个 C++ 模块示例阐明了基本模式。模块接口单元使用 export module 来声明模块的名称及其公共接口，而模块实现单元使用 module 来贡献模块的内部实现。
除了基本的 export 和 import，C++ 20 模块还引入了几个高级特性来处理复杂的项目结构和遗留代码转换。C++ 23 模块通过进一步的改进和增强的编译器支持继续这一演进。
一个命名模块是共享相同模块名称的模块单元（源文件）的集合。
export module MyModule;)。当您 import MyModule 时，此单元导出的内容变为可见。export module 声明的单元都是接口单元。这包括主接口单元和分区接口单元。module MyModule;（没有 export）声明的单元是实现单元。它有助于模块的内部逻辑，但不会直接向导入者暴露接口。代码移植到模块期间的一个重大挑战是与依赖预处理器宏进行配置的现有头文件集成。全局模块片段解决了这个问题。
// mymodule_with_legacy.ixx
module; // 全局模块片段的开始
#define USE_ADVANCED_FEATURE 1 // 在全局片段中定义的宏
#include <legacy_header.h> // 包含遗留头文件（假设）
export module mymodule_with_legacy; // 全局模块片段的结束，模块的开始
import <iostream>; // 导入标准库模块
export void perform_action() {
#if USE_ADVANCED_FEATURE
std::cout << "高级操作已执行！" << std::endl;
#else
std::cout << "基本操作已执行！" << std::endl;
#endif
// 如有需要，可使用 legacy_header.h 中的声明
}
module; 声明开启全局模块片段。此片段中的任何 #include 指令或宏定义都会在模块本身定义之前进行处理。这允许模块与依赖预处理器的遗留代码交互，而不会在模块的接口中造成宏污染。这里定义的宏确实会影响此片段中包含的头文件的处理，但不会影响模块稍后作为头单元导入的头文件。
对于大型模块，如果开发者希望将实现细节保留在主接口单元内部但完全对导入者隐藏，C++ 20 模块提供了私有模块片段。
// main_module.ixx
export module main_module;
export int public_function();
module :private; // 私有模块片段的开始
// 此函数仅在 main_module.ixx 内部可见，
// 对于任何导入 'main_module' 的代码均不可见。
int internal_helper_function() {
return 36;
}
int public_function() {
return internal_helper_function();
}
module :private; 声明标记了模块公共接口与其私有实现细节之间的边界。此声明之后主接口单元中的代码仅对该单元以及属于同一命名模块的任何其他单元可访问，但对外部导入者不可访问。这通过允许单个 .ixx 文件表示一个模块，同时清晰地分离公共和私有部分来增强封装。包含私有模块片段的模块单元通常将是其模块的唯一单元。
对于非常大的模块，将其分解为更小、更易于管理的单元是有益的。模块分区（C++ 20 模块）实现了这种内部模块化。分区本质上是较大命名模块的子模块。
// large_module_part1.ixx - 分区接口单元
export module large_module:part1; // 声明 'large_module' 的一个名为 'part1' 的分区
export void do_something_in_part1();
// large_module_part1.cpp - 分区实现单元
module large_module:part1; // 将此文件链接到 'part1' 分区
void do_something_in_part1() {
// 实现
}
// large_module_main.ixx - 'large_module' 的主模块接口单元
export module large_module;
// 导出-导入分区接口。这使得当 'large_module' 被导入时，`do_something_in_part1` 可见。
export import :part1;
// 可以导入一个实现分区（如果存在），但不能导出它。
// import :internal_part;
export void do_main_thing() {
do_something_in_part1(); // 可以直接调用分区函数
}
分区仅在命名模块内部可见。外部翻译单元不能直接导入 large_module:part1;。相反，主模块接口单元 (large_module_main.ixx) 必须 export import :part1; 才能使 part1 的导出实体对 large_module 的导入者可见。这种分层结构提供了一种管理大型软件开发项目中复杂性的健壮方式。
C++ 20 模块还引入了头单元，允许您使用 import <header_name>; 或 import "header_name"; 导入传统的头文件。当一个头文件作为头单元导入时，它被解析一次，其声明被高效地提供，类似于模块。至关重要的是，与 #include 不同，在导入翻译单元中 import 语句之前定义的预处理器宏不影响头单元本身的处理。这提供了更一致的行为，并可以显著加快大型头文件的编译速度。
// my_app.cpp
#define CUSTOM_SETTING 10 // 此宏不影响 <vector> 或 "my_utility.h"
import <vector>; // 将标准 vector 头文件作为头单元导入
import "my_utility.h"; // 将自定义头文件作为头单元导入（假设）
int main() {
std::vector<int> numbers = {1, 2, 3};
// ...
return 0;
}
这种区别对于代码移植工作很重要。当头文件依赖预处理器指令进行配置，并且该配置必须受导入翻译单元的预处理器状态影响时，全局模块片段是合适的解决方案。否则，作为头单元导入是 #include 的更快、更清晰的替代方案。
将大型现有 C++ 项目进行代码转换和代码移植到完整的模块系统可以是一个渐进的过程。开发者无需一次性转换整个代码库。C++ 模块旨在与传统头文件无缝共存。
import 模块和 #include 头文件。这种灵活性允许增量采用，一次转换一个组件或库。关键是进行实验和测量。开发者应根据是否实现了编译时间有意义的减少和代码组织的改进来做出采用决策。
对 C++ 20 模块的支持在主要编译器中持续演进。
随着 C++ 23 模块的普及，进一步的改进和增强的编译器成熟度将提升整体开发者体验。通往完整且优化模块支持的旅程仍在进行中，但 C++ 20 奠定的基础代表了 C++ 软件开发方式的深刻转变。这种持续的演进预示着语言将拥有一个更加健壮和高效的未来。
C++ 模块是一项变革性的特性，从根本上重塑了 C++ 中的编程实践。它们直接解决了与基于头文件的系统相关的长期问题，例如编译缓慢、宏干扰和弱封装。通过提供一个健壮的显式接口定义和高效编译系统，C++ 模块增强了代码组织、改进了构建时间，并促进了更清晰的关注点分离。采用 C++ 20 模块并为 C++ 23 模块的未来增强做好准备，使开发者能够构建更具可伸缩性、可维护性和高效的软件开发项目，从而开启语言的新时代。