标准库模块导入 ​

什么是标准库模块 ​

C++23 引入了两个标准库命名模块:std 和 std.compat。这两个模块让你可以用一条 import 语句获得整个 C++ 标准库的所有功能,不再需要记忆和管理几十个不同的 #include 头文件。

  • import std; —— 导入所有标准库声明(在 std 命名空间中)
  • import std.compat; —— 导入 std 的所有内容,再加上 C 运行库的全局命名空间函数(如 ::printf、::strlen、::fopen 等)

std vs std.compat ​

模块包含内容适用场景
std所有 C++ 标准库声明(std:: 命名空间)新项目,纯 C++ 风格
std.compatstd 的全部内容 + C 库全局命名空间函数旧项目迁移,需要 printf 等全局名

两个模块都不导出宏。这意味着 assert、errno、offsetof、va_arg 等依赖宏的功能不能通过 import std; 获得,仍然需要 #include 对应的头文件。

基本示例 ​

cpp
// ============================
// 示例1:import std 的基本用法
// ============================

import std;  // 一行导入整个标准库

int main() {
    // iostream 功能
    std::cout << "Hello, C++23 Modules!" << std::endl;

    // vector 功能
    std::vector<int> nums{1, 2, 3, 4, 5};

    // algorithm 功能
    std::sort(nums.begin(), nums.end(), std::greater<>{});

    // string 功能
    std::string result;
    for (int n : nums) {
        result += std::to_string(n) + " ";
    }

    std::cout << result << std::endl;  // 输出: 5 4 3 2 1

    // map 功能
    std::map<std::string, int> scores{
        {"Alice", 95},
        {"Bob", 87},
        {"Charlie", 92}
    };

    for (const auto& [name, score] : scores) {
        std::cout << name << ": " << score << std::endl;
    }

    return 0;
}
cpp
// ============================
// 示例2:import std.compat 的用法
// ============================

import std.compat;  // 导入标准库 + C 全局命名空间函数

int main() {
    // 可以直接用 C 风格的全局函数
    printf("Hello from printf!\n");

    // 也可以用 C++ 风格
    std::cout << "Hello from cout!" << std::endl;

    // C 字符串函数(全局命名空间)
    const char* src = "C++23 modules";
    char dst[64];
    strcpy(dst, src);
    printf("复制的字符串: %s, 长度: %zu\n", dst, strlen(dst));

    // C++ 容器和算法
    std::vector<double> values{3.14, 2.71, 1.41, 1.73};
    std::sort(values.begin(), values.end());

    for (double v : values) {
        printf("%.2f ", v);  // 用 printf 格式化输出
    }
    printf("\n");

    // C 数学函数(全局命名空间)
    printf("sqrt(2) = %.6f\n", sqrt(2.0));
    printf("pow(2, 10) = %.0f\n", pow(2.0, 10.0));

    return 0;
}
cpp
// ============================
// 示例3:配合 C++23 std::print 使用
// ============================

import std;

int main() {
    // C++23 的 std::println 替代 std::cout + std::endl
    std::println("Hello, C++23!");

    // 格式化输出
    std::string name = "C++";
    int version = 23;
    std::println("Language: {}, Version: {}", name, version);

    // 容器直接格式化(C++23)
    std::vector<int> v{10, 20, 30};
    std::println("Vector: {}", v);

    // 计算并输出
    auto sum = std::accumulate(v.begin(), v.end(), 0);
    std::println("Sum = {}", sum);

    return 0;
}

import std 与 #include 的性能对比 ​

方式编译时间(大致)说明
#include <iostream>~100ms单个标准库头文件
包含 10+ 个标准库头文件~500ms+多个头文件累加
import std;~10-50ms导入整个标准库

import std; 比包含单个头文件都快,更不用说包含多个头文件了。这是因为模块接口只需要编译一次,之后的导入只是读取二进制接口文件。

从 #include 迁移到 import std ​

迁移通常很简单——把所有标准库的 #include 替换成一条 import std;:

cpp
// 迁移前:
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <memory>
#include <functional>

// 迁移后:
import std;

// 代码本身不需要改动(如果都是用 std:: 前缀的话)

需要注意的特殊情况:

场景处理方式
使用 printf 等全局 C 函数改用 import std.compat;
使用 assert 宏保留 #include <cassert>
使用 errno 宏保留 #include <cerrno>
使用 offsetof 宏保留 #include <cstddef>
使用 va_arg 等可变参数宏保留 #include <cstdarg>

在模块中使用 import std ​

cpp
// ============================
// 文件:mylib.cppm(模块接口单元)
// ============================
export module mylib;

import std;  // 在模块中导入标准库

export namespace mylib {
    // 使用标准库类型作为参数和返回值
    std::string uppercase(std::string_view input) {
        std::string result(input);
        std::transform(result.begin(), result.end(), result.begin(),
                       [](unsigned char c) { return std::toupper(c); });
        return result;
    }

    // 使用标准库容器
    std::vector<int> fibonacci(int count) {
        std::vector<int> result;
        result.reserve(count);
        int a = 0, b = 1;
        for (int i = 0; i < count; ++i) {
            result.push_back(a);
            int next = a + b;
            a = b;
            b = next;
        }
        return result;
    }

    // 使用智能指针
    struct Config {
        std::string name;
        int value;
    };

    std::unique_ptr<Config> make_config(std::string name, int value) {
        return std::make_unique<Config>(std::move(name), value);
    }
}

// ============================
// 文件:main.cpp
// ============================
import std;
import mylib;

int main() {
    std::cout << mylib::uppercase("hello world") << std::endl;

    auto fibs = mylib::fibonacci(10);
    for (int f : fibs) {
        std::cout << f << " ";
    }
    std::cout << std::endl;

    auto cfg = mylib::make_config("debug", 1);
    std::cout << cfg->name << " = " << cfg->value << std::endl;

    return 0;
}

编译标准库模块 ​

在使用 import std; 之前,需要先编译标准库模块。不同编译器的方式不同:

MSVC ​

bat
REM 编译标准库模块
cl /std:c++latest /EHsc /c "%VCToolsInstallDir%\modules\std.ixx"

REM 编译使用模块的程序
cl /std:c++latest /EHsc /reference "std=std.ifc" main.cpp std.obj

Clang (libc++) ​

bash
# 预编译标准库模块
clang++ -std=c++23 -stdlib=libc++ --precompile \
    -o std.pcm /path/to/libc++/modules/std.cppm

# 编译程序
clang++ -std=c++23 -stdlib=libc++ \
    -fmodule-file=std=std.pcm -o main std.pcm main.cpp

GCC ​

bash
# GCC 15+ 支持 import std
g++ -std=c++23 -fmodules -c main.cpp

适用场景 ​

  • 新的 C++23 项目——直接用 import std; 作为默认方式
  • 现有项目迁移——用 import std.compat; 保持 C 全局函数兼容
  • 大型项目——显著减少编译时间
  • 教学和原型开发——不需要记忆头文件名

常见问题 ​

import std 和 import std.compat 可以在同一个项目中混用吗?

可以。不同翻译单元可以用不同的导入方式。一个文件用 import std;,另一个用 import std.compat;,不会冲突。

import std 后还能 #include 标准库头文件吗?

技术上可以混用,但没有必要(除了需要宏的情况)。混用可能在某些编译器上引起问题,建议统一使用一种方式。

import std 导入了所有标准库,不会增加二进制大小吗?

不会。import std; 只是让声明可见,链接器只会链接实际使用的符号。未使用的标准库组件不会出现在最终的二进制文件中。

import std 支持 C++20 的标准库功能吗?

import std; 是 C++23 的特性,但它导入的是当前编译器实现的完整标准库,包括 C++20 和更早版本的所有功能。

为什么 assert 宏不能通过 import std 获得?

模块不导出宏,这是模块的设计原则之一。assert 是一个预处理宏,无法通过模块机制传递。需要 assert 时仍然要 #include <cassert>。

注意事项 ​

  • import std; 是 C++23 特性,需要编译器支持 C++23
  • 标准库模块不导出宏(assert、errno 等需要单独 #include)
  • 使用前需要先编译标准库模块(具体方式因编译器而异)
  • import std; 不会增加二进制文件大小
  • 构建系统(CMake 等)对标准库模块的支持仍在完善中
  • std 和 std.compat 可以在同一项目的不同文件中混用
  • 编译器和标准库的版本必须匹配

编译器支持情况 ​

编译器import std 支持import std.compat 支持最低版本
MSVC支持支持19.35 (VS 2022 17.5)
Clang (libc++)支持支持17.0
GCC (libstdc++)支持支持15.0

总结 ​

C++23 的 import std; 和 import std.compat; 让标准库的使用变得前所未有地简单——一行代码就能获得整个标准库。import std; 提供 std 命名空间中的所有声明,import std.compat; 在此基础上增加 C 库的全局命名空间函数。标准库模块不导出宏,需要 assert 等宏功能时仍要 #include 对应头文件。相比传统 #include,import std; 的编译速度快了一个数量级以上,因为模块接口只编译一次。从 #include 迁移到 import std; 通常只需要把所有标准库头文件的 #include 替换为一条 import std;,代码本身不需要修改。