C++20 新特性——模块（Modules）

官网：https://fr.cppreference.com/w/cpp/language/modules.html

一、首先看个例子

下面是一个模拟大型项目中使用 C++20 模块的示例，展示了如何将一个复杂系统拆分为多个模块、模块分区（Module Partitions）以及模块间的依赖关系。这个例子模拟了一个简单的 "用户管理系统"，包含核心模块、数据模块、网络模块和主程序模块。
项目结构

project/
├── core/                # 核心模块（基础类型、工具函数）
│   ├── core.ixx         # 核心模块接口（导出公共API）
│   ├── base.cppm        # 模块分区：基础类型定义
│   └── utils.cppm       # 模块分区：工具函数实现
├── data/                # 数据模块（用户数据处理）
│   ├── data.ixx         # 数据模块接口
│   └── user.cppm        # 模块分区：用户数据操作
├── net/                 # 网络模块（数据传输）
│   ├── net.ixx          # 网络模块接口
│   └── client.cppm      # 模块分区：客户端通信
└── main.cpp             # 主程序（导入并使用各模块）

1. 核心模块（core）

核心模块提供基础类型和工具函数，通过模块分区拆分功能。

• core/base.cppm（模块分区：基础类型）

export module core:base;  // 模块分区声明

// 导出基础类型
export enum class Status {
    Success,
    Error,
    NotFound
};

export struct UserID {
    unsigned int value;
    bool operator==(const UserID&) const = default;
};

• core/utils.cppm（模块分区：工具函数）

export module core:utils;  // 模块分区声明
import :base;              // 导入同模块的其他分区

// 导出工具函数
export Status to_status(int code) {
    switch (code) {
        case 0: return Status::Success;
        case 1: return Status::Error;
        case 2: return Status::NotFound;
        default: return Status::Error;
    }
}

export std::string to_string(Status s) {
    switch (s) {
        case Status::Success: return "Success";
        case Status::Error: return "Error";
        case Status::NotFound: return "NotFound";
        default: return "Unknown";
    }
}

• core/core.ixx（核心模块接口单元）

export module core;  // 模块声明
// 聚合并导出所有分区的内容
export import :base;
export import :utils;

2. 数据模块（data）

数据模块依赖核心模块，处理用户数据逻辑。

• data/user.cppm（模块分区：用户数据操作）

export module data:user;
import core;  // 导入核心模块
#include <string>
#include <unordered_map>

// 内部数据结构（不导出，模块内可见）
namespace detail {
    std::unordered_map<UserID, std::string> users;
}

// 导出用户操作类
export class UserManager {
public:
    Status add_user(UserID id, std::string name) {
        if (detail::users.contains(id)) {
            return Status::Error;
        }
        detail::users[id] = std::move(name);
        return Status::Success;
    }

    Status get_user(UserID id, std::string& out_name) const {
        if (auto it = detail::users.find(id); it != detail::users.end()) {
            out_name = it->second;
            return Status::Success;
        }
        return Status::NotFound;
    }
};

• data/data.ixx（数据模块接口单元）

export module data;
export import :user;  // 导出用户操作分区

3. 网络模块（net）

网络模块依赖核心模块和数据模块，处理数据传输。

• net/client.cppm（模块分区：客户端通信）

export module net:client;
import core;
import data;  // 依赖数据模块
#include <string>
#include <iostream>

// 导出网络客户端类
export class Client {
private:
    UserManager& user_manager;  // 依赖注入数据模块的类
public:
    Client(UserManager& um) : user_manager(um) {}

    // 模拟网络请求：获取用户名称
    std::string fetch_username(UserID id) {
        std::string name;
        const auto status = user_manager.get_user(id, name);
        if (status == Status::Success) {
            return "User " + std::to_string(id.value) + ": " + name;
        }
        return "Error: " + to_string(status);
    }
};

• net/net.ixx（网络模块接口单元）

export module net;
export import :client;  // 导出客户端通信分区

4. 主程序（main.cpp）

import core;    // 导入核心模块
import data;    // 导入数据模块
import net;     // 导入网络模块
#include <iostream>

int main() {
    // 使用数据模块
    UserManager um;
    const UserID id1{1001};
    const UserID id2{1002};
    
    um.add_user(id1, "Alice");
    um.add_user(id2, "Bob");

    // 使用网络模块
    Client client(um);
    std::cout << client.fetch_username(id1) << "\n";  // 输出：User 1001: Alice
    std::cout << client.fetch_username(UserID{999}) << "\n";  // 输出：Error: NotFound

    return 0;
}

• 模块特性体现
• 模块化拆分：按功能拆分模块（core/data/net），每个模块通过分区进一步拆分细节，降低耦合度。
• 接口隔离：通过 export 明确导出公共 API，内部实现（如 detail::users）对外不可见，减少命名污染。
• 依赖管理：模块间通过 import 显式声明依赖（如 net 依赖 data 和 core），编译时可优化依赖检查。
• 编译效率：模块只编译一次，后续修改单个模块（如 data）时，只需重新编译依赖它的模块（如 net），无需全量重编。

编译说明（使用gcc 为例）

# 创建输出目录
mkdir -p build

# 编译core模块的分区
g++ -std=c++20 -fmodules-ts -c core/base.cppm -o build/base.o
g++ -std=c++20 -fmodules-ts -c core/utils.cppm -o build/utils.o
# 编译core模块接口
g++ -std=c++20 -fmodules-ts -c core/core.ixx -o build/core.o

# 编译data模块的分区
g++ -std=c++20 -fmodules-ts -c data/user.cppm -o build/user.o -I.

# 编译data模块接口
g++ -std=c++20 -fmodules-ts -c data/data.ixx -o build/data.o -I.

# 编译net模块的分区
g++ -std=c++20 -fmodules-ts -c net/client.cppm -o build/client.o -I.

# 编译net模块接口
g++ -std=c++20 -fmodules-ts -c net/net.ixx -o build/net.o -I.

# 编译主程序并链接
g++ -std=c++20 -fmodules-ts main.cpp -o build/main \
    build/core.o build/base.o build/utils.o \
    build/data.o build/user.o \
    build/net.o build/client.o \
    -I.

/opt/compiler/gcc-12/bin/g++ -std=c++20  -fmodules-ts -x c++ -c core/base.cppm -o build/base.o
/opt/compiler/gcc-12/bin/g++ -std=c++20 -fmodules-ts -x c++  -c core/utils.cppm -o build/utils.o
/opt/compiler/gcc-12/bin/g++ -std=c++20 -fmodules-ts -x c++ -c core/core.ixx -o build/core.o

/opt/compiler/gcc-12/bin/g++ -std=c++20 -fmodules-ts -x c++ -c data/user.cppm -o build/user.o

这个例子展示了大型项目中模块的典型组织方式，实际项目可能包含更多模块（如日志、配置、UI 等），但核心思想是通过模块实现功能隔离、依赖清晰化和编译优化。

二、与include区别

C++20 模块（Modules）的编译处理方式与传统的#include机制有本质区别，核心目标是避免头文件的文本重复解析，通过预编译的二进制接口实现高效的依赖管理。其编译流程可分为以下关键阶段，涉及多个特殊处理步骤：

1、核心区别：从 “文本替换” 到 “二进制接口”

传统#include是文本级别的复制粘贴：每个包含头文件的源文件都会重复解析头文件内容，导致大量冗余编译。
而模块通过预编译的二进制接口文件（BMI，Binary Module Interface） 实现复用：模块仅需编译一次生成 BMI，其他模块通过import导入时直接读取 BMI，无需重复解析源码。

2、模块编译的关键概念

在理解流程前，需明确几个核心概念：

• 模块接口单元（Module Interface Unit）：包含export module 模块名;的源文件（通常以.ixx或.cppm为后缀），负责定义模块的公共接口（通过export导出类型 / 函数），是生成 BMI 的关键。
• 模块实现单元（Module Implementation Unit）：包含module 模块名;的源文件，仅实现接口单元中声明的功能，不导出内容，也不生成 BMI。
• 模块分区（Module Partitions）：形如export module 模块名:分区名;的文件，用于拆分大型模块的实现，需通过接口单元聚合（export import :分区名;）后对外暴露。
• BMI（Binary Module Interface）：模块接口编译后生成的二进制文件（不同编译器后缀不同，如 GCC 的.gcm、MSVC 的.ifc），包含模块导出的类型信息、函数签名、模板实例化规则等，供其他模块导入时使用。

3、模块的编译流程

以一个依赖链模块A → 模块B → 主程序为例，编译流程如下：

• 1. 编译模块接口单元，生成 BMI
     编译器首先处理模块的接口单元（如A.ixx）：
     解析接口单元中的代码，检查export声明的有效性（如导出的类型是否完整定义）。
     生成对应的 BMI 文件（如A.gcm），包含模块 A 对外暴露的所有接口信息（类型布局、函数签名、模板规则等），但不包含实现细节。

注：模块分区的接口（如A:part.ixx）会先编译为分区的 BMI，再由模块 A 的接口单元聚合后生成模块 A 的最终 BMI。

• 2. 编译模块实现单元
     模块的实现单元（如A_impl.cppm，包含module A;）依赖模块 A 的接口：
     编译器通过模块名找到对应的 BMI（A.gcm），验证实现与接口的一致性（如函数参数是否匹配）。
     编译实现单元生成目标文件（如A_impl.o），但不生成新的 BMI（实现细节不对外暴露）。
• 3. 处理依赖模块的编译
     若模块 B 依赖模块 A（import A;）：

编译器会先检查模块 A 的 BMI 是否已生成（若未生成，会触发模块 A 的编译，确保依赖顺序）。
解析模块 B 的接口单元时，通过A.gcm获取模块 A 的接口信息，无需解析 A 的源码。
生成模块 B 的 BMI（B.gcm）和目标文件（如B.o），流程同模块 A。

• 4. 编译主程序及链接
     主程序（main.cpp，包含import B;）的编译：

导入模块 B 时，直接读取B.gcm获取接口信息，验证主程序中对 B 的使用是否合法（如调用的函数是否存在）。
编译主程序生成目标文件（main.o）。
链接阶段，将模块 A 的实现（A_impl.o）、模块 B 的实现（B.o）、主程序（main.o）等目标文件链接为可执行文件。

4、编译器的依赖管理

模块编译的核心优势之一是显式依赖追踪：

• 编译器会通过import语句构建模块依赖图（如main → B → A），确保被依赖的模块先编译（生成 BMI），避免传统头文件中 “无序包含” 导致的依赖混乱。
• 若模块 A 的接口发生变更（如导出的函数签名修改），仅需重新编译模块 A 的接口单元（更新 BMI），以及所有直接或间接依赖 A 的模块（B 和 main）；模块 A 的实现变更（不影响接口）则仅需重新编译 A 的实现单元，不影响依赖它的模块。

5、与传统头文件编译的对比

特性	传统#include机制	模块（Modules）机制
解析方式	文本替换，重复解析头文件内容	读取预编译的 BMI，仅解析一次
依赖管理	隐式依赖（需手动控制包含顺序）	显式依赖（编译器自动管理顺序）
编译速度	大型项目中冗余解析导致速度慢	避免重复解析，增量编译效率高
接口与实现隔离	头文件暴露实现细节（如私有成员）	仅通过export暴露接口，实现隐藏
命名冲突风险	高（全局命名空间污染）	低（模块内命名空间独立）

6、总结

模块的编译过程核心是通过BMI 文件实现接口的预编译与复用，结合显式的依赖管理，解决了传统头文件机制的冗余解析、依赖混乱、接口暴露等问题。这使得大型 C++ 项目的编译速度显著提升，同时代码组织更清晰、封装性更强。主流编译器（GCC 11+、Clang 12+、MSVC 2019+）已逐步完善对模块的支持，但具体实现细节（如 BMI 格式、编译命令）可能略有差异。