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;
}