C++学习：六个月从基础到就业——C++20：模块(Modules)与其他特性

本文是我C++学习之旅系列的第五十三篇技术文章，也是第三阶段"现代C++特性"的第十五篇，深入探讨C++20引入的模块(Modules)系统及其他重要特性。查看完整系列目录了解更多内容。

引言

C++的预处理器和头文件系统诞生于近50年前，虽然它们服务了几代C++程序员，但随着项目规模增长，头文件的各种缺陷日益凸显：编译缓慢、宏的副作用、符号污染、包含顺序依赖等问题困扰着开发者。C++20终于引入了期待已久的模块(Modules)系统，彻底改变了C++代码的组织方式。

同时，C++20还引入了其他一些重要特性，如格式库(std::format)、日历与时区支持、新的同步原语等，进一步增强了C++的功能性和开发效率。这些特性与前文讨论的概念(Concepts)、协程(Coroutines)和范围(Ranges)共同构成了C++20的"四大支柱"。

本文将详细介绍C++20模块系统及其他重要特性，帮助你掌握这些现代C++工具，并将它们融入到日常开发中。

C++20：模块(Modules)与其他特性
- 引言
- 目录
- 模块系统
  - 传统头文件的问题
  - 模块基础概念
  - 模块接口与实现
  - 导入与导出
  - 模块分区
  - 全局模块片段
- 编译优势与实现机制
  - 编译速度提升原理
  - 模块映射文件
  - 构建系统集成
- 实际应用示例
  - 模块化数学库
  - 组件化游戏引擎
  - 迁移策略
- 标准库模块
  - 标准库的模块化
  - 使用标准库模块
- 格式库
  - 基本格式化
  - 格式说明符
  - 自定义格式化
- 日历与时区
  - 日历类型
  - 时区支持
  - 日期运算
- 其他C++20特性
  - 三路比较运算符
  - 指定初始化
  - constexpr的增强
- 编译器支持情况
  - 主流编译器支持
  - 特性测试宏
- 最佳实践与展望
  - 采纳模块的建议
  - C++23新特性预览
- 总结

模块系统

传统头文件的问题

C++的传统头文件系统存在多项根本性问题：

重复解析开销：每个包含头文件的翻译单元都要重新解析该头文件
宏污染：头文件中的宏会影响后续包含的所有代码
包含顺序依赖：头文件的包含顺序可能影响编译结果
符号暴露：头文件中的所有符号都会暴露给包含者
预编译头文件(PCH)的局限性：PCH虽能缓解编译速度问题，但使用繁琐且有诸多限制

这些问题在大型项目中尤为明显，导致构建时间过长、难以维护和频繁出错。考察一个典型的头文件包含案例：

// config.h - 包含全局配置
#define DEBUG_LEVEL 2
#define MAX_BUFFER_SIZE 1024// utils.h
#include <vector>
#include <string>
// 可能会被config.h中的宏影响
std::vector<char> create_buffer(int size = MAX_BUFFER_SIZE);// component.h
#include "config.h"  // 如果在utils.h之后包含会有不同行为
#include "utils.h"
// component.h中的代码会看到所有utils.h暴露的符号和宏

模块基础概念

C++20模块系统提供了一种新的代码组织方式，具有以下核心特点：

编译一次：模块接口文件只需解析一次，生成编译后的模块单元
没有宏泄漏：模块中的宏不会泄漏到导入模块的代码中
与包含顺序无关：导入模块的顺序不影响语义
显式导出：只有显式导出的声明才对模块外部可见
不支持条件导出：导出的符号不受条件编译影响，增加稳定性

基本的模块定义和使用语法：

// math.cppm - 模块接口文件
export module math;  // 声明模块名称// 导出函数声明
export int add(int a, int b);
export int subtract(int a, int b);// 不导出的辅助函数（模块内部可见，外部不可见）
int validate(int x) {return x >= 0 ? x : 0;
}// helper.cpp - 模块实现文件
module math;  // 实现属于math模块int add(int a, int b) {return validate(a) + validate(b);
}int subtract(int a, int b) {return validate(a) - validate(b);
}// main.cpp - 使用模块的文件
import math;  // 导入math模块int main() {int result = add(5, 3);     // 可以访问// int valid = validate(5); // 错误：validate不可见return 0;
}

模块接口与实现

模块系统允许明确分离接口与实现：

模块接口单元(Module Interface Unit)：包含export module声明和导出的符号
模块实现单元(Module Implementation Unit)：包含module声明和实现代码

这种分离促进了更好的代码组织和封装：

// geometry.cppm - 模块接口
export module geometry;// 导出命名空间中的所有内容
export namespace geometry {struct Point {double x, y;};double distance(const Point& p1, const Point& p2);class Circle {public:Circle(const Point& center, double radius);double area() const;bool contains(const Point& p) const;private:Point center_;double radius_;};
}// geometry_impl.cpp - 模块实现
module geometry;
#include <cmath>  // 实现单元可以包含头文件，不会泄漏namespace geometry {double distance(const Point& p1, const Point& p2) {double dx = p1.x - p2.x;double dy = p1.y - p2.y;return std::sqrt(dx*dx + dy*dy);}Circle::Circle(const Point& center, double radius): center_(center), radius_(radius) {}double Circle::area() const {return M_PI * radius_ * radius_;}bool Circle::contains(const Point& p) const {return distance(center_, p) <= radius_;}
}// application.cpp - 使用几何模块
import geometry;
#include <iostream>int main() {geometry::Point p1{0, 0};geometry::Point p2{3, 4};std::cout << "Distance: " << geometry::distance(p1, p2) << std::endl;geometry::Circle c{{0, 0}, 5};std::cout << "Area: " << c.area() << std::endl;std::cout << "Contains p2: " << (c.contains(p2) ? "yes" : "no") << std::endl;return 0;
}

导入与导出

模块系统的核心机制是导入与导出：

导出(export)：使符号在模块外部可见
导入(import)：访问其他模块导出的符号

导出有多种语法形式：

export module my_module;  // 模块声明// 单个声明导出
export void func1();
export int var1 = 42;// 组合导出
export {class MyClass;enum Color { Red, Green, Blue };template<typename T> T max(T a, T b);
}// 命名空间导出
export namespace tools {void utility_function();class Helper {// ...};
}

导入操作更加简单直接：

// 导入单个模块
import my_module;// 导入多个模块
import std.core;     // 标准库核心模块
import graphics.2d;  // 自定义模块可以包含非字母数字字符

模块分区

大型模块可以分解为多个部分，这些部分被称为模块分区(Module Partitions)：

// 主模块接口
export module graphics;// 导出其分区
export import :shapes;
export import :colors;// shapes分区接口
export module graphics:shapes;export struct Point {double x, y;
};export class Circle {// ...
};// colors分区接口
export module graphics:colors;export enum class Color {Red, Green, Blue, Yellow
};export struct RGB {int r, g, b;
};// 使用主模块
import graphics;  // 可访问所有导出的分区// 也可以只导入特定分区
import graphics:colors;  // 只导入颜色相关功能

分区提供了组织大型模块的有效方式，而无需创建过多独立模块。

全局模块片段

有时模块需要包含传统头文件，但又不希望这些头文件中的宏泄漏到模块外部。全局模块片段(Global Module Fragment)提供了解决方案：

// 全局模块片段，必须位于模块声明之前
module;  // 标记全局模块片段开始#include <vector>
#include <string>
#include "legacy_header.h"
#define INTERNAL_MACRO 42  // 这个宏不会泄漏到模块外// 模块声明，结束全局模块片段
export module data_processing;// 使用前面包含的类型
export std::vector<std::string> split(const std::string& text, char delimiter);// 实现
std::vector<std::string> split(const std::string& text, char delimiter) {// 使用INTERNAL_MACRO，但它不会泄漏到导入此模块的代码中std::vector<std::string> result;// 实现细节...return result;
}

全局模块片段使得模块系统与现有代码的过渡更加平滑。

编译优势与实现机制

编译速度提升原理

模块相比传统头文件的主要编译优势包括：

一次性解析：模块接口只需解析一次，然后编译结果可被重用
去除预处理开销：无需重复执行文本替换和条件编译
避免符号重复解析：模块中的符号只被解析一次
并行编译支持：模块依赖关系明确，有利于并行构建

对于包含大量模板的代码尤为明显：

// 传统方式，每个翻译单元都需要实例化模板
// header.h
template<typename T>
T complex_calculation(T input) {// 大量模板代码...
}// 模块方式，模板只解析一次，按需实例化
export module math_templates;export template<typename T>
T complex_calculation(T input) {// 大量模板代码...
}

在大型项目中，编译时间可能减少50%甚至更多。

模块映射文件

为了实现快速加载模块信息，编译器通常会生成二进制模块映射文件(BMI, Binary Module Interface)：

# 编译模块接口，生成BMI文件
$ clang++ -std=c++20 --precompile math.cppm -o math.pcm# 使用BMI编译实现文件
$ clang++ -std=c++20 -fmodule-file=math.pcm math_impl.cpp -c -o math_impl.o# 使用BMI编译使用方
$ clang++ -std=c++20 -fmodule-file=math.pcm main.cpp math_impl.o -o program

不同编译器的BMI格式不兼容，但工作原理类似：存储已解析的声明和符号信息，以便快速加载。

构建系统集成

模块给构建系统带来了新的挑战，需要扫描源文件确定模块依赖关系。现代构建系统正在适应这一变化：

# CMake中的模块支持示例
add_library(math_modulemath.cppm           # 模块接口文件math_impl.cpp       # 模块实现文件
)
set_target_properties(math_module PROPERTIESCXX_STANDARD 20
)# 使用模块的可执行文件
add_executable(app main.cpp)
target_link_libraries(app PRIVATE math_module)

有些构建系统已经提供了专门的模块支持，如CMake 3.28+、Meson、Build2等。

实际应用示例

模块化数学库

以一个简单数学库为例，展示模块化设计：

// math.cppm - 主模块接口
export module math;// 导出子模块
export import :basic;
export import :statistics;
export import :linear_algebra;// 主模块自身也可以导出内容
export namespace math {constexpr double PI = 3.14159265358979323846;constexpr double E = 2.71828182845904523536;
}// math_basic.cppm - 基础运算子模块
export module math:basic;export namespace math {double sin(double x);double cos(double x);double tan(double x);template<typename T>T abs(T value) {return value < 0 ? -value : value;}
}// math_statistics.cppm - 统计子模块
export module math:statistics;
import :basic;  // 模块内部导入，不需exportexport namespace math {template<typename Iterator>auto mean(Iterator begin, Iterator end) {using value_type = typename std::iterator_traits<Iterator>::value_type;value_type sum = 0;int count = 0;for (auto it = begin; it != end; ++it) {sum += *it;count++;}return sum / count;}template<typename Iterator>auto standard_deviation(Iterator begin, Iterator end) {auto m = mean(begin, end);// ...计算标准差的实现...return 0.0;  // 简化实现}
}// 使用数学库
import math;
#include <vector>
#include <iostream>int main() {std::vector<double> values = {1.0, 2.0, 3.0, 4.0, 5.0};double avg = math::mean(values.begin(), values.end());double sin_value = math::sin(math::PI / 6);std::cout << "Mean: " << avg << std::endl;std::cout << "Sin(π/6): " << sin_value << std::endl;return 0;
}

组件化游戏引擎

模块特别适合于组件化设计，以游戏引擎为例：

// engine.cppm - 主引擎模块
export module game_engine;// 导出各个子系统
export import :core;
export import :rendering;
export import :physics;
export import :audio;
export import :input;// engine_core.cppm - 核心系统
export module game_engine:core;export namespace engine {class Entity;class Component;class Transform;class Scene;// 核心接口定义...
}// engine_rendering.cppm - 渲染系统
export module game_engine:rendering;
import :core;  // 依赖核心模块export namespace engine::rendering {class Renderer;class Mesh;class Material;class Texture;// 渲染相关接口...
}// 游戏代码
import game_engine;  // 导入整个引擎
// 或者只导入需要的部分
import game_engine:rendering;
import game_engine:physics;class MyGame {
private:engine::Scene scene;engine::rendering::Renderer renderer;// ...
};

模块的组织反映了软件架构，使代码结构更清晰。

迁移策略

从传统头文件迁移到模块系统可以采用渐进式策略：

模块化标头(Header Units)：将现有头文件作为模块导入

import <vector>;  // 导入标准头文件作为模块
import "legacy.h";  // 导入项目头文件作为模块

创建接口包装器：为现有库创建模块接口

// third_party_lib.cppm
export module third_party_lib;module;  // 全局模块片段
#include "third_party/library.h"// 导出需要的符号
export namespace third_party {using ::ThirdPartyClass;using ::third_party_function;
}

逐步模块化：从低级别组件开始，逐步向上构建模块体系

标准库模块

标准库的模块化

C++20将标准库组织成了几个主要模块：

std：整个标准库
std.core：核心语言支持和常用组件
std.memory：内存管理相关组件
std.threading：线程和同步原语
std.regex：正则表达式库
std.filesystem：文件系统库
std.io：输入输出流库

使用标准库模块

导入标准库模块比包含头文件更加简洁和高效：

// 传统方式
#include <vector>
#include <string>
#include <algorithm>
#include <iostream>// 模块方式
import std.core;  // 包含vector, string, algorithm等
import std.io;    // 包含iostream等int main() {std::vector<std::string> names = {"Alice", "Bob", "Charlie"};std::sort(names.begin(), names.end());for (const auto& name : names) {std::cout << name << std::endl;}return 0;
}

标准库模块消除了头文件顺序依赖的问题，并提高了编译速度。

格式库

基本格式化

C++20引入的std::format库受Python的str.format()启发，提供了类型安全的格式化功能：

#include <format>
#include <iostream>
#include <string>int main() {// 基本格式化std::string message = std::format("Hello, {}!", "world");std::cout << message << std::endl;  // 输出: Hello, world!// 多参数格式化auto text = std::format("Name: {}, Age: {}, Score: {:.2f}", "Alice", 25, 92.5);std::cout << text << std::endl;  // 输出: Name: Alice, Age: 25, Score: 92.50// 参数索引auto reordered = std::format("Reordered: {2}, {0}, {1}", "A", "B", "C");std::cout << reordered << std::endl;  // 输出: Reordered: C, A, Breturn 0;
}

std::format比printf更安全，比std::ostringstream更简洁，同时避免了国际化问题。

格式说明符

格式说明符提供了对输出格式的精确控制：

#include <format>
#include <iostream>int main() {// 整数格式化std::cout << std::format("Decimal: {0:d}, Hex: {0:x}, Octal: {0:o}, Binary: {0:b}", 42) << std::endl;// 浮点数格式化std::cout << std::format("Default: {0}, Fixed: {0:.2f}, Scientific: {0:.2e}, Hex: {0:a}", 3.14159) << std::endl;// 对齐和填充std::cout << std::format("Left: |{:<10}|", "Left") << std::endl;std::cout << std::format("Right: |{:>10}|", "Right") << std::endl;std::cout << std::format("Center: |{:^10}|", "Center") << std::endl;std::cout << std::format("Custom: |{:*^10}|", "Custom") << std::endl;  // 自定义填充字符// 符号控制std::cout << std::format("Default: {0}, Always: {0:+}, Space: {0: }", 42) << std::endl;std::cout << std::format("Default: {0}, Always: {0:+}, Space: {0: }", -42) << std::endl;return 0;
}

输出结果：

Decimal: 42, Hex: 2a, Octal: 52, Binary: 101010
Default: 3.14159, Fixed: 3.14, Scientific: 3.14e+00, Hex: 0x1.921f9f01b866ep+1
Left: |Left      |
Right: |     Right|
Center: |  Center  |
Custom: |**Custom**|
Default: 42, Always: +42, Space:  42
Default: -42, Always: -42, Space: -42

自定义格式化

可以为自定义类型实现格式化支持：

#include <format>
#include <iostream>
#include <string>struct Point {double x, y;
};// 在std命名空间特化formatter模板
template<>
struct std::formatter<Point> {// 解析格式说明符constexpr auto parse(std::format_parse_context& ctx) {auto it = ctx.begin();if (it != ctx.end() && *it != '}')throw std::format_error("Invalid format for Point");return it;}// 格式化值auto format(const Point& p, std::format_context& ctx) const {return std::format_to(ctx.out(), "({}, {})", p.x, p.y);}
};// 更复杂的格式化控制
struct Color {int r, g, b;
};template<>
struct std::formatter<Color> {enum class FormatMode { Decimal, Hex };FormatMode mode = FormatMode::Decimal;constexpr auto parse(std::format_parse_context& ctx) {auto it = ctx.begin();if (it != ctx.end() && *it != '}') {if (*it == 'x')mode = FormatMode::Hex;else if (*it == 'd')mode = FormatMode::Decimal;elsethrow std::format_error("Invalid format for Color");++it;}return it;}auto format(const Color& c, std::format_context& ctx) const {if (mode == FormatMode::Hex)return std::format_to(ctx.out(), "#{:02x}{:02x}{:02x}", c.r, c.g, c.b);return std::format_to(ctx.out(), "rgb({}, {}, {})", c.r, c.g, c.b);}
};int main() {Point p{3.5, -2.0};std::cout << std::format("Point: {}", p) << std::endl;Color c{255, 128, 64};std::cout << std::format("Color(default): {}", c) << std::endl;std::cout << std::format("Color(hex): {:x}", c) << std::endl;return 0;
}

输出结果：

Point: (3.5, -2)
Color(default): rgb(255, 128, 64)
Color(hex): #ff8040

日历与时区

日历类型

C++20引入了全新的日历和时区库，提供了比C++11的<chrono>更丰富的日期处理功能：

#include <chrono>
#include <iostream>int main() {using namespace std::chrono;// 创建日期year_month_day today = floor<days>(system_clock::now());std::cout << "Today: " << today << std::endl;// 日期组件year y = today.year();month m = today.month();day d = today.day();std::cout << "Year: " << y << std::endl;std::cout << "Month: " << m << std::endl;std::cout << "Day: " << d << std::endl;// 日期运算year_month_day next_month = today + months{1};year_month_day next_year = today + years{1};std::cout << "Next month: " << next_month << std::endl;std::cout << "Next year: " << next_year << std::endl;// 日期比较bool is_future = next_month > today;std::cout << "Is next month in the future? " << is_future << std::endl;// 星期几year_month_weekday weekday_date = year_month_weekday{y, m, weekday{3}};std::cout << "First Wednesday: " << weekday_date << std::endl;return 0;
}

时区支持

时区支持让时间处理更加准确：

#include <chrono>
#include <iostream>int main() {using namespace std::chrono;// 当前时间（系统时区）auto now = system_clock::now();std::cout << "System time: " << now << std::endl;// 不同时区的时间try {// 纽约时间auto nyc = zoned_time("America/New_York", now);std::cout << "New York: " << nyc << std::endl;// 东京时间auto tokyo = zoned_time("Asia/Tokyo", now);std::cout << "Tokyo: " << tokyo << std::endl;// 伦敦时间auto london = zoned_time("Europe/London", now);std::cout << "London: " << london << std::endl;// 时区转换auto tokyo_from_nyc = zoned_time("Asia/Tokyo", nyc);std::cout << "Tokyo time when it's now in NYC: " << tokyo_from_nyc << std::endl;} catch (const std::runtime_error& e) {std::cerr << "Time zone error: " << e.what() << std::endl;}return 0;
}

日期运算

C++20提供了丰富的日期运算功能：

#include <chrono>
#include <iostream>int main() {using namespace std::chrono;// 创建日期year_month_day date{2023y, May, 15d};// 计算持续时间year_month_day other_date{2023y, February, 20d};auto diff = sys_days(date) - sys_days(other_date);std::cout << "Days between: " << diff.count() << std::endl;// 日期算术auto three_weeks_later = sys_days(date) + weeks{3};year_month_day result_date = year_month_day{three_weeks_later};std::cout << "Three weeks later: " << result_date << std::endl;// 检查特殊情况（如闰年）auto feb29_2024 = year_month_day{2024y, February, 29d};auto feb29_2023 = year_month_day{2023y, February, 29d};std::cout << "2024-02-29 is " << (feb29_2024.ok() ? "valid" : "invalid") << std::endl;std::cout << "2023-02-29 is " << (feb29_2023.ok() ? "valid" : "invalid") << std::endl;// 使用系统时钟获取今天auto today = floor<days>(system_clock::now());auto weekday = year_month_weekday{floor<days>(today)}.weekday();std::cout << "Today is " << weekday << std::endl;return 0;
}

其他C++20特性

三路比较运算符

C++20引入了三路比较运算符(<=>)，简化了相等和顺序比较的实现：

#include <compare>
#include <iostream>
#include <string>class Version {
public:int major, minor, patch;// 自动生成所有比较运算符auto operator<=>(const Version&) const = default;// 等效于手动实现以下所有运算符:// ==, !=, <, <=, >, >=
};// 自定义三路比较
class Person {
public:std::string name;int age;// 自定义三路比较，先按姓名后按年龄std::strong_ordering operator<=>(const Person& other) const {if (auto cmp = name <=> other.name; cmp != 0)return cmp;return age <=> other.age;}// 仍需定义相等运算符，但可以利用三路比较bool operator==(const Person& other) const {return (*this <=> other) == 0;}
};int main() {Version v1{1, 2, 3};Version v2{1, 3, 0};std::cout << std::boolalpha;std::cout << "v1 < v2: " << (v1 < v2) << std::endl;std::cout << "v1 == v2: " << (v1 == v2) << std::endl;Person p1{"Alice", 30};Person p2{"Alice", 25};Person p3{"Bob", 20};std::cout << "p1 < p2: " << (p1 < p2) << std::endl;std::cout << "p1 < p3: " << (p1 < p3) << std::endl;return 0;
}

三路比较运算符有三种结果类型，精确表达比较语义：

std::strong_ordering：完全相等的值等价（如整数）
std::weak_ordering：逻辑相等但可能物理不同（如不区分大小写的字符串比较）
std::partial_ordering：某些值可能无法比较（如浮点数，考虑NaN）

指定初始化

指定初始化(Designated Initializers)允许按名称初始化结构体成员：

#include <iostream>struct Point3D {double x;double y;double z;
};struct Config {int width = 800;int height = 600;bool fullscreen = false;std::string title = "Default Window";
};int main() {// 使用指定初始化器Point3D p1 = {.x = 1.0, .y = 2.0, .z = 3.0};// 只初始化部分成员，其余使用默认值Config cfg = {.width = 1920, .height = 1080};// 初始化顺序必须与声明顺序相同Point3D p2 = {.x = 5.0, .z = 10.0, .y = 7.5};  // 错误std::cout << "Point: (" << p1.x << ", " << p1.y << ", " << p1.z << ")" << std::endl;std::cout << "Config: " << cfg.width << "x" << cfg.height << ", fullscreen: " << cfg.fullscreen << ", title: " << cfg.title << std::endl;return 0;
}

指定初始化提高了代码可读性和可维护性，特别是对于包含多个成员的结构体。

constexpr的增强

C++20进一步增强了constexpr的能力：

#include <iostream>
#include <vector>
#include <string>// constexpr动态内存分配
constexpr std::vector<int> create_fibonacci(int n) {std::vector<int> result;if (n > 0) result.push_back(0);if (n > 1) result.push_back(1);for (int i = 2; i < n; ++i) {result.push_back(result[i-1] + result[i-2]);}return result;
}// constexpr虚函数
struct Base {constexpr virtual int calculate(int x) const {return x;}
};struct Derived : Base {constexpr int calculate(int x) const override {return x * 2;}
};// constexpr try-catch
constexpr int safe_divide(int a, int b) {try {if (b == 0) throw std::runtime_error("Division by zero");return a / b;} catch (const std::runtime_error&) {return 0;}
}// 编译期计算强大示例
constexpr auto compile_time_fib = create_fibonacci(10);int main() {std::cout << "Compile-time Fibonacci sequence:";for (int n : compile_time_fib) {std::cout << " " << n;}std::cout << std::endl;constexpr Base* ptr = new Derived();constexpr int result = ptr->calculate(5);  // 虚函数调用在编译期解析std::cout << "Constexpr virtual function: " << result << std::endl;delete ptr;constexpr int div_result = safe_divide(10, 2);constexpr int div_error = safe_divide(10, 0);std::cout << "Safe division: " << div_result << ", " << div_error << std::endl;return 0;
}

这些增强使得更多的计算可以在编译期完成，提高运行时性能。

编译器支持情况

主流编译器支持

截至2023年底，三大主流编译器对C++20模块的支持情况：

MSVC：Visual Studio 2019 16.8及以上版本提供较完整的模块支持
Clang：Clang 14开始提供较好的模块支持
GCC：GCC 11开始提供部分模块支持，GCC 12改进了支持

其他C++20特性的支持通常更加成熟：

特性	MSVC	Clang	GCC
模块	VS 2019 16.8+	Clang 14+	GCC 11+
格式库	VS 2019 16.10+	Clang 14+	GCC 13+
日历与时区	VS 2019 16.10+	Clang 14+	GCC 11+
三路比较	VS 2019 16.7+	Clang 10+	GCC 10+
指定初始化	VS 2019 16.5+	Clang 10+	GCC 8+

特性测试宏

可以使用特性测试宏检测编译器是否支持特定功能：

#include <iostream>int main() {std::cout << "C++ Standard: " << __cplusplus << std::endl;// 检测模块支持#ifdef __cpp_modulesstd::cout << "Modules supported, version: " << __cpp_modules << std::endl;#elsestd::cout << "Modules not supported" << std::endl;#endif// 检测格式库支持#ifdef __cpp_lib_formatstd::cout << "Format library supported, version: " << __cpp_lib_format << std::endl;#elsestd::cout << "Format library not supported" << std::endl;#endif// 检测三路比较运算符支持#ifdef __cpp_impl_three_way_comparisonstd::cout << "Three-way comparison supported, version: " << __cpp_impl_three_way_comparison << std::endl;#elsestd::cout << "Three-way comparison not supported" << std::endl;#endifreturn 0;
}