标准库模块导入
什么是标准库模块
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.compat | std 的全部内容 + C 库全局命名空间函数 | 旧项目迁移,需要 printf 等全局名 |
两个模块都不导出宏。这意味着 assert、errno、offsetof、va_arg 等依赖宏的功能不能通过 import std; 获得,仍然需要 #include 对应的头文件。
基本示例
// ============================
// 示例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;
}// ============================
// 示例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;
}// ============================
// 示例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;:
// 迁移前:
#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
// ============================
// 文件: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
REM 编译标准库模块
cl /std:c++latest /EHsc /c "%VCToolsInstallDir%\modules\std.ixx"
REM 编译使用模块的程序
cl /std:c++latest /EHsc /reference "std=std.ifc" main.cpp std.objClang (libc++)
# 预编译标准库模块
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.cppGCC
# 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;,代码本身不需要修改。