standrad c++

在 C++20 中引入的模块化（Modules）技术为解决传统头文件带来的编译耦合和重复编译问题提供了一种全新的解决方案。本文将从模块的基本概念、核心语法、常见问题以及实际项目中如何引入模块进行拆解，帮助你在真实项目中快速上手并获得编译性能与代码可维护性的双重收益。

1. 模块化的目标

• 消除头文件的多重编译：传统头文件需要在每个包含它的源文件中重新编译，导致编译时间线性增长。
• 提供更清晰的接口：模块接口（module interface unit）只公开必要的符号，隐藏内部实现细节，增强信息隐藏。
• 支持更细粒度的依赖：编译器可以只重新编译受影响的模块单元，而非整个项目。

2. 核心概念

• 模块单元（module unit）：可以是接口单元（module interface unit）或实现单元（implementation unit）。
• 导出（export）：声明在接口单元中 export 的符号才对外可见。
• 模块分区（partition）：通过 partition 关键字将模块拆分为多个文件，便于并行编译。

3. 基本语法示例

3.1 模块接口单元

// math_module.ixx
export module math_module;           // 定义模块名
export import std.core;              // 导入标准库（可选）

export namespace math {
    export int add(int a, int b);
    export int multiply(int a, int b);
}

int math::add(int a, int b) { return a + b; }
int math::multiply(int a, int b) { return a * b; }

3.2 使用模块

// main.cpp
import math_module;                  // 引入模块

#include <iostream>

int main() {
    std::cout << "3 + 4 = " << math::add(3, 4) << '\n';
    std::cout << "3 * 4 = " << math::multiply(3, 4) << '\n';
}

3.3 模块分区示例

// geometry.ixx
export module geometry:shape;        // 主模块分区
export namespace shape {
    export struct Point { double x, y; };
}

// geometry_impl.ixx
module geometry:shape;               // 实现分区
#include <cmath>

export namespace shape {
    export double distance(const Point& a, const Point& b) {
        double dx = a.x - b.x, dy = a.y - b.y;
        return std::sqrt(dx*dx + dy*dy);
    }
}

4. 常见陷阱与解决方案

问题	原因	解决方案
编译器报 error: module 'X' is not a C++ module	头文件仍被 #include 方式包含。	只通过 import 引入模块，删除 #include。
模块依赖关系错乱	未正确声明 export 或 import 的顺序。	确保在同一个接口单元内 export 所有符号，且在实现单元前声明依赖。
模块在 IDE 中无法识别	IDE 还未完整支持 C++20 模块。	使用命令行编译器（如 g++ 12+、clang++ 14+）测试，等待 IDE 更新。

5. 与传统头文件的对比

特性	传统头文件	模块化
编译重复	每个 CPP 文件都编译一遍	只编译一次，其他文件复用已编译模块
命名冲突	容易出现宏冲突	模块提供命名空间隔离，避免宏污染
依赖可视化	难以追踪	模块接口显式导出，依赖关系更透明

6. 在大型项目中的实践

1. 先行评估

   • 统计项目中头文件的数量、包含次数。
   • 识别热路径和经常变更的模块。

2. 逐步迁移

   • 从业务逻辑较为独立的子模块开始，例如网络通信、数学库等。
   • 为每个子模块创建对应的 module.ixx 文件，逐步将原有头文件改为模块化。

3. 构建系统改造

   • CMake：使用 target_sources 指定 INTERFACE 和 PRIVATE，并添加 -fmodules-ts 或 -fmodules 选项。
   • Ninja 或 Make：为每个模块生成独立的对象文件，缓存其编译结果。

4. 持续集成

   • 在 CI 环境中开启模块化编译选项，监控编译时间变化。
   • 对比旧版与新版编译日志，验证是否真正提升了编译性能。

7. 未来展望

• 更细粒度的编译缓存：未来编译器会进一步支持模块级别的增量编译，减少重编译时间。
• 跨平台模块化：目前主要在 Linux/macOS 上成熟，Windows 仍在完善。
• 标准化更完善：C++23 将继续完善模块特性，例如 `import ` 的标准化语法。

结语

C++20 模块化为 C++ 语言带来了前所未有的编译性能提升与代码组织方式的革新。虽然在迁移过程中可能会遇到一定的学习成本和工具兼容问题，但从长远来看，它将显著降低维护成本、提升团队协作效率。只要在项目中逐步引入、持续评估效果，你就能在保持 C++ 强大特性的同时，获得更快、更可靠的编译体验。

在多线程环境下，单例模式需要确保只有一个实例被创建，并且在并发访问时不会出现竞争条件。C++17 以后可以利用 std::call_once 和 std::once_flag 来实现最简单、最安全的单例。下面从设计思路、实现细节和性能考量三个角度，逐步阐述如何编写一个线程安全的单例。

---

1. 设计思路

1. 懒汉式（Lazy）
   • 只在第一次使用时创建实例，避免不必要的初始化成本。
2. 线程安全
   • 使用 std::call_once 确保初始化只执行一次。
3. 避免“双重检查锁定”
   • 双重检查锁定（Double-Check Locking）在某些编译器/硬件上仍可能产生数据竞争。
4. 保证对象在整个程序生命周期内有效
   • 单例实例应在程序结束前保持存在，或使用 std::shared_ptr 与自定义删除器管理生命周期。

---

2. 实现代码

#include <iostream>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

class ThreadSafeSingleton {
public:
    // 提供全局访问点
    static ThreadSafeSingleton& Instance() {
        std::call_once(initFlag_, &ThreadSafeSingleton::Init);
        return *instance_;
    }

    // 禁止复制与移动
    ThreadSafeSingleton(const ThreadSafeSingleton&) = delete;
    ThreadSafeSingleton& operator=(const ThreadSafeSingleton&) = delete;
    ThreadSafeSingleton(ThreadSafeSingleton&&) = delete;
    ThreadSafeSingleton& operator=(ThreadSafeSingleton&&) = delete;

    // 示例业务函数
    void DoWork() {
        std::cout << "Thread " << std::this_thread::get_id() << " is using singleton at address " << this << "\n";
    }

private:
    ThreadSafeSingleton() { std::cout << "Singleton constructed\n"; }
    ~ThreadSafeSingleton() { std::cout << "Singleton destroyed\n"; }

    static void Init() {
        instance_ = std::unique_ptr <ThreadSafeSingleton>(new ThreadSafeSingleton);
    }

    static std::once_flag initFlag_;
    static std::unique_ptr <ThreadSafeSingleton> instance_;
};

// 静态成员定义
std::once_flag ThreadSafeSingleton::initFlag_;
std::unique_ptr <ThreadSafeSingleton> ThreadSafeSingleton::instance_ = nullptr;

// 简单测试
int main() {
    constexpr int threadCount = 10;
    std::vector<std::thread> workers;

    for (int i = 0; i < threadCount; ++i) {
        workers.emplace_back([]{
            ThreadSafeSingleton::Instance().DoWork();
        });
    }

    for (auto& t : workers) t.join();
    return 0;
}

说明：

• std::call_once 与 std::once_flag 保证 Init() 只会被调用一次，所有线程在第一次访问 Instance() 时会阻塞直到实例完成初始化。
• 由于使用 unique_ptr，单例在程序退出时会被正确析构。若需要更细粒度的控制（例如懒销毁），可以改用 shared_ptr 或手动管理析构。
• Instance() 返回引用，调用者无需担心内存泄漏。

---

3. 性能与可读性评估

方案	初始化开销	访问开销	可读性	线程安全	适用场景
static local（C++11）	低（只需一次）	低（无锁）	高	通过编译器实现	轻量级
std::call_once	低（只一次）	低（无锁）	中	高	需要显式控制
double-checked locking	低	低（锁粒度小）	低	需细心	避免 call_once 的实现细节

• static local：最简洁，C++11 标准保证线程安全。
• call_once：更直观地表明“只调用一次”，适合需要手动管理生命周期或需要在特定时机初始化的场景。

---

4. 常见错误与陷阱

错误	说明	解决方案
在构造函数里调用单例	可能导致递归调用	避免在构造函数里访问 Instance()
使用裸指针	可能导致悬挂指针	使用 unique_ptr 或 shared_ptr
忘记删除拷贝构造/赋值	可能导致多个实例	delete 拷贝构造/赋值运算符
多次包含头文件导致重复定义	链接错误	使用 include guards 或 #pragma once

---

5. 小结

• std::call_once 是 C++ 中最推荐的线程安全单例实现方式。
• 对于大多数场景，static local（C++11 及以后）足够简洁且安全；如果需要更细粒度的控制或在类外初始化，则 call_once 是更好的选择。
• 记住禁用拷贝/移动构造和赋值运算符，确保单例的唯一性。

通过上述实现，你可以在任何多线程 C++ 应用中安全、可靠地使用单例模式，而不必担心竞争条件或初始化问题。

C++20正式加入协程（coroutines）后，协程在语言层面得到了标准化，使得实现异步、生成器等复杂控制流变得异常简单。本文将带你从C++17的协程实验性实现说起，探讨协程的底层原理、常见用法以及与传统异步模型（如线程+future、回调）的区别与优劣。

1. 何为协程？

协程是一种轻量级的用户级线程，允许函数在执行过程中“挂起”（yield）并在需要时恢复。与线程不同，协程的切换是由程序显式控制的，几乎不需要上下文切换开销。协程分为三类：

• 生成器：每次返回一个值后挂起；
• 异步：等待某些事件完成后恢复；
• 协作式：多个协程在运行时通过显式 co_await 或 co_yield 进行切换。

2. C++17 的协程实验性实现

C++17 为协程提供了“预编译器”功能，主要通过 coro.h 头文件实现，编译器支持 co_await、co_yield、co_return。然而该实验版本不完整，缺少关键类型（如 std::experimental::coroutine_handle）的完整实现，且只能通过第三方库（如 Boost.Coroutine2）来使用。

典型的实验性协程代码（需 Boost.Coroutine2）：

#include <boost/coroutine2/all.hpp>
#include <iostream>

void generator(boost::coroutines2::coroutine <void>::push_type &sink) {
    for (int i = 0; i < 5; ++i) {
        sink(i); // co_yield 的实现
    }
}

int main() {
    boost::coroutines2::coroutine <void>::pull_type source(
        [](boost::coroutines2::coroutine <void>::push_type &sink) {
            generator(sink);
        });

    while (source) {
        std::cout << source.get() << '\n';
        ++source; // 手动切换
    }
}

虽然能实现生成器，但缺乏语言级语法糖和更复杂的异步功能。

3. C++20 协程的完整实现

C++20 提供了标准化的协程库，核心类为 std::coroutine_handle，并引入了 std::suspend_always、std::suspend_never 等默认挂起策略。协程函数的返回类型必须是支持 co_await 的 awaitable。

3.1 生成器实现

#include <coroutine>
#include <iostream>

template<typename T>
struct generator {
    struct promise_type;
    using handle_type = std::coroutine_handle <promise_type>;

    struct promise_type {
        T current_value;
        std::suspend_always yield_value(T value) {
            current_value = value;
            return {};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        generator get_return_object() {
            return generator{handle_type::from_promise(*this)};
        }
        void unhandled_exception() { std::exit(1); }
        void return_void() {}
    };

    handle_type coro;
    generator(handle_type h) : coro(h) {}
    ~generator() { coro.destroy(); }

    struct iterator {
        handle_type coro;
        bool operator==(std::default_sentinel_t) const noexcept { return !coro || coro.done(); }
        iterator &operator++() { coro.resume(); return *this; }
        T operator*() const { return coro.promise().current_value; }
    };

    iterator begin() { return iterator{coro}; }
    std::default_sentinel_t end() { return {}; }
};

generator <int> range(int start, int end) {
    for (int i = start; i <= end; ++i)
        co_yield i;
}

int main() {
    for (auto v : range(1, 5))
        std::cout << v << ' ';
}

这段代码几乎与传统循环一样直观，且编译器自动管理协程栈。

3.2 异步任务（async）

C++20 标准库中 std::future 已被 std::future（已支持异步）与 std::promise 结合使用。协程可以返回 std::future，使用 co_await 等待异步结果。

#include <coroutine>
#include <future>
#include <iostream>

std::future <int> async_add(int a, int b) {
    co_return a + b;
}

int main() {
    auto fut = async_add(3, 4);
    std::cout << "Result: " << fut.get() << '\n';
}

此处 co_return 自动将结果封装为 std::future，无需手动包装。

4. 协程与传统异步模型的对比

特点	协程	线程+future	回调
切换成本	轻量级，栈已在堆上	上下文切换开销大	需要手动维护状态机
可读性	接近同步代码	可读性一般	嵌套回调导致“回调地狱”
错误处理	通过 try/catch 统一	同样可使用 try/catch	需在每层回调中处理
资源管理	通过 RAII 自动	需显式锁/同步	难以保证释放

协程在高并发 I/O 密集型程序（如网络服务器）中表现尤为突出：相比起大量线程，它们占用更少资源并保持代码直观。

5. 常见坑与最佳实践

1. 栈大小限制
   虽然协程的栈在堆上，但若协程内部递归深度过大，仍会导致堆栈耗尽。应避免深递归或使用循环代替。

2. 异常传播
   若协程内部抛出异常，co_return 不会捕获，需要在 promise_type::unhandled_exception 中处理。

3. 同步与异步的混用
   同步函数调用异步协程时，要注意 co_await 的上下文。最好在统一的事件循环中执行协程。

4. 调试工具
   目前主流 IDE 对协程调试支持有限，建议使用 -fno-omit-frame-pointer 编译参数，并配合 llvm-symbolizer。

6. 结语

C++20 的协程为现代 C++ 开发者提供了一种既轻量又高效的并发编程模型。通过把异步逻辑写成看似同步的代码，降低了复杂性并提升了可维护性。虽然协程在 I/O 密集型场景中表现突出，但在 CPU 密集型计算时，线程仍是更优选择。掌握协程的使用后，你将能写出更简洁、更高性能的 C++ 程序。

C++17引入了std::filesystem库，它为文件系统操作提供了一套跨平台、类型安全且易用的接口。相较于传统的C风格的文件操作函数（如fopen、mkdir、rename等），std::filesystem 能够让我们用更直观、更现代的方式完成文件与目录的创建、复制、移动、删除、遍历以及属性查询等任务。本文将从基本概念、常用操作、性能与安全性等方面，详细剖析如何在实际项目中使用std::filesystem，帮助读者快速掌握并应用到自己的C++项目中。

1. 基本概念与命名空间

#include <filesystem>
namespace fs = std::filesystem;

• path：代表文件系统路径的对象，支持操作符 operator/ 进行路径拼接，能够自动处理不同平台下的分隔符。
• directory_iterator / recursive_directory_iterator：用于遍历目录，支持递归遍历。
• file_status / directory_entry：用于查询文件属性（如是否为文件、目录、符号链接等）。

2. 常用文件操作

2.1 创建与删除

// 创建单个文件夹
fs::create_directory("data");

// 创建多级文件夹（等同于mkdir -p）
fs::create_directories("logs/2026/02");

// 删除空文件夹
fs::remove("logs/2026/02");

// 删除非空文件夹（递归删除）
fs::remove_all("logs/2026");

2.2 复制、移动与重命名

// 复制文件
fs::copy("source.txt", "backup.txt", fs::copy_options::overwrite_existing);

// 复制目录（递归）
fs::copy("src_folder", "dst_folder", fs::copy_options::recursive | fs::copy_options::overwrite_existing);

// 移动文件
fs::rename("old.txt", "new.txt");

// 移动目录
fs::rename("tmp_folder", "final_folder");

2.3 读取文件内容（基于路径对象）

#include <fstream>
#include <iostream>

void printFile(const fs::path& p) {
    std::ifstream ifs(p, std::ios::binary);
    if (!ifs) {
        std::cerr << "Cannot open " << p << '\n';
        return;
    }
    std::string line;
    while (std::getline(ifs, line)) {
        std::cout << line << '\n';
    }
}

2.4 遍历目录

for (const auto& entry : fs::directory_iterator("src")) {
    std::cout << entry.path() << " is " << (entry.is_directory() ? "directory" : "file") << '\n';
}

// 递归遍历
for (const auto& entry : fs::recursive_directory_iterator("src")) {
    std::cout << entry.path() << '\n';
}

2.5 查询文件属性

fs::file_status status = fs::status("config.yaml");
std::cout << "File size: " << fs::file_size("config.yaml") << " bytes\n";
std::cout << "Last write time: " << fs::last_write_time("config.yaml") << '\n';

3. 性能与安全性考量

3.1 性能

• 延迟执行：大多数 std::filesystem 函数在调用时即执行，未做延迟加载；因此，在需要批量处理大量文件时，建议使用 directory_iterator 并做合理的错误处理，以避免因单个错误导致整个批处理失败。
• 异步：C++17 并未提供异步文件操作接口，若需提高 I/O 性能，可结合 std::async 或第三方库（如 Boost.Asio）进行并发 I/O。

3.2 安全

• 异常：std::filesystem 的多数操作默认抛出 std::filesystem::filesystem_error。开发者应使用 try/catch 处理异常，或在调用前使用 exists()、is_directory() 等函数做预检查。
• 权限：在多用户系统下，文件/目录权限可能影响操作。permissions() 函数可查询/修改权限，注意符号链接安全。

4. 与旧接口的互操作

如果项目中仍有使用 boost::filesystem 或 C 标准库文件操作的代码，可以轻松迁移：

fs::path p1("/tmp/example.txt");
boost::filesystem::path p2(p1.native());  // 转为 boost::filesystem

同样，std::filesystem::path 支持 std::string、const char*、std::wstring 等构造。

5. 小结

std::filesystem 为 C++ 程序员提供了一套统一、类型安全且符合现代 C++ 风格的文件系统 API。它不仅简化了代码编写，还增强了跨平台兼容性。掌握并熟练使用该库，可以显著提升项目的可维护性和开发效率。希望本文能为你在实际项目中应用 std::filesystem 打下坚实基础。

在多线程环境下，单例（Singleton）模式需要保证实例的唯一性和线程安全。自C++11起，语言层面已经提供了对线程安全初始化的支持，简化了实现。下面从理论到代码演示几种常用的实现方式，并讨论它们的优缺点。

1. C++11 的“懒汉式”Meyers Singleton

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;  // 函数内静态对象
        return instance;
    }

    // 删除拷贝构造和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
    ~Singleton() = default;
};

原理
C++11 规定，对函数内静态对象的初始化是 线程安全 的。编译器会在第一次调用 instance() 时执行一次初始化，后续调用不再重复。只要编译器遵守标准，这种方式既简单又高效。

优点

• 代码最短，最易读。
• 无需手动同步，避免死锁与竞态。
• 延迟初始化（懒加载），在首次使用时才创建。

缺点

• 需要 C++11 或更高。
• 对析构时的销毁顺序（尤其是多线程结束时）有些微的不确定性。
• 对于跨进程共享单例（如共享内存）无法直接使用。

2. 双重检查锁定（Double‑Checked Locking）

#include <atomic>
#include <mutex>

class Singleton {
public:
    static Singleton* instance() {
        Singleton* tmp = instance_.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            tmp = instance_.load(std::memory_order_relaxed);
            if (!tmp) {
                tmp = new Singleton();
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
    ~Singleton() = default;

    static std::atomic<Singleton*> instance_;
    static std::mutex mutex_;
};

std::atomic<Singleton*> Singleton::instance_{nullptr};
std::mutex Singleton::mutex_;

原理

• 第一次检查 instance_ 是否已创建，若未创建则进入锁区。
• 再次检查（再次锁定前）确认实例仍未创建，避免多线程同时创建多份实例。
• 使用 std::atomic 与内存序保证可见性。

优点

• 兼容 C++11 之前的编译器（但需要显式同步）。
• 控制细粒度的锁，性能相对良好。

缺点

• 代码较繁琐，易出错。
• 需要手动管理 delete，若程序退出时未释放会造成内存泄漏。
• 需要 std::atomic 的正确使用，错误的内存序会导致数据竞争。

3. 静态局部变量与 std::call_once

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(initFlag_, []{
            instance_ = new Singleton();
        });
        return *instance_;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
    ~Singleton() = default;

    static Singleton* instance_;
    static std::once_flag initFlag_;
};

Singleton* Singleton::instance_ = nullptr;
std::once_flag Singleton::initFlag_;

原理

• std::call_once 确保给定的 lambda 只执行一次。
• std::once_flag 负责同步，内部实现使用原子操作和锁。

优点

• 与双重检查锁定相似，但代码更简洁。
• 支持 C++11 及以上。

缺点

• 与 std::call_once 的实现细节相关，某些老旧编译器可能不完美。
• 与静态局部变量相比，缺少自动销毁（除非在 atexit 注册销毁函数）。

4. 适配多进程环境的单例（共享内存单例）

在多进程共享内存时，单例需要在共享内存段内创建。下面演示一种基于 boost::interprocess 的实现思路（可根据需求替换为 POSIX shm_open/mmap 等）：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>

struct Singleton {
    Singleton() = default;
    // 业务成员...
};

Singleton* getSingleton() {
    using namespace boost::interprocess;
    static managed_shared_memory segment(open_or_create, "MySharedMemory", 65536);
    static interprocess_mutex mutex;
    static Singleton* instance = nullptr;

    if (!instance) {
        boost::interprocess::scoped_lock <interprocess_mutex> lock(mutex);
        if (!instance) {
            instance = segment.construct <Singleton>("SingletonInstance")();
        }
    }
    return instance;
}

说明

• managed_shared_memory 在共享内存区创建对象。
• interprocess_mutex 处理进程间同步。
• 适用于多进程共享同一实例（如数据库连接池、缓存等）。

5. 何时使用哪种实现？

场景	推荐实现	备注
单进程、C++11+	Meyers Singleton	最简洁，线程安全
旧编译器（C++03）	双重检查锁定	需要手动同步
需要手动销毁	std::call_once + 自定义析构	兼顾性能与可控性
多进程共享	共享内存 + 进程间同步	复杂度更高，需考虑映射、权限

6. 常见陷阱与最佳实践

1. 删除拷贝构造/赋值：避免被复制产生多个实例。
2. 懒加载 vs 预初始化：若实例化成本高且启动阶段不需要，使用懒加载；若想避免启动时的延迟，考虑在程序初始化阶段显式创建。
3. 销毁顺序：静态局部对象在程序退出时按逆序销毁；若涉及跨文件的静态单例，需小心析构顺序。
4. 异常安全：若构造函数抛异常，静态局部对象会再次尝试初始化，确保异常不导致程序崩溃。
5. 多线程测试：在多核机器上使用 std::thread 并发访问 instance()，验证线程安全。

7. 小结

• C++11 为单例提供了最直接的线程安全实现：静态局部对象。
• 对于更旧的环境或更细粒度的控制，可使用双重检查锁定或 std::call_once。
• 多进程共享单例需要进程间同步与共享内存。
• 关键在于删除拷贝、避免析构顺序问题、保证线程安全。

通过以上方式，你可以根据项目需求和编译环境，选用最合适的单例实现，既保证了线程安全，又保持了代码的可维护性。

在现代C++20中，协程（coroutines）为我们提供了一种以声明式方式编写异步代码的强大工具。本文将带你从零开始，利用协程实现一个极其简化的异步IO框架，帮助你更直观地理解协程的工作原理、状态机实现以及与事件循环的结合方式。

一、协程基本概念

协程是一种特殊的函数，它可以在执行过程中挂起（co_await、co_yield、co_return）并在需要时恢复。C++20把协程分解为三大核心：

1. 挂起点（awaitable）：可以被co_await挂起的对象。
2. 协程对象：由编译器生成的状态机，内部维护协程的执行状态。
3. 协程句柄（promise）：协程内部的上下文，提供挂起/恢复接口。

二、简化的事件循环

为了演示协程的实战，我们首先实现一个非常简易的事件循环：

#include <queue>
#include <functional>
#include <iostream>

using Task = std::function<void()>;

class EventLoop {
public:
    void schedule(Task t) { queue_.push(std::move(t)); }

    void run() {
        while (!queue_.empty()) {
            auto t = std::move(queue_.front());
            queue_.pop();
            t();
        }
    }

private:
    std::queue <Task> queue_;
};

这里的Task是一个包装了待执行代码块的可调用对象，EventLoop会不断地弹出队列中的任务并执行。

三、创建可 await 的异步任务

我们定义一个简化的awaitable，它将协程挂起并在稍后通过事件循环恢复：

#include <coroutine>
#include <chrono>
#include <thread>

struct AsyncSleep {
    std::chrono::milliseconds dur;
    EventLoop& loop;

    struct awaiter {
        std::chrono::milliseconds dur;
        EventLoop& loop;
        std::chrono::steady_clock::time_point start;

        bool await_ready() const noexcept { return false; }
        void await_suspend(std::coroutine_handle<> h) {
            // 将恢复工作包装成任务
            loop.schedule([h, dur = dur, start = start]() {
                auto now = std::chrono::steady_clock::now();
                if (now - start < dur) {
                    // 若未到时，重新调度
                    loop.schedule([h, dur, start]() { h.resume(); });
                } else {
                    h.resume();
                }
            });
            start = std::chrono::steady_clock::now();
        }
        void await_resume() noexcept {}
    };

    awaiter operator co_await() noexcept {
        return awaiter{dur, loop, std::chrono::steady_clock::now()};
    }
};

该AsyncSleep在co_await时会挂起协程，并在指定时间后通过事件循环恢复。

四、协程函数的实现

下面是一个使用上述AsyncSleep的协程函数示例：

struct AsyncTask {
    struct promise_type {
        AsyncTask get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {}
        void return_void() {}
    };
};

AsyncTask my_async_job(EventLoop& loop) {
    std::cout << "Task start\n";
    co_await AsyncSleep{std::chrono::milliseconds(500), loop};
    std::cout << "Halfway through\n";
    co_await AsyncSleep{std::chrono::milliseconds(500), loop};
    std::cout << "Task finished\n";
}

这里我们用自定义的promise_type让协程始终在同步调用点执行，真正的挂起/恢复逻辑由AsyncSleep处理。

五、主程序驱动

int main() {
    EventLoop loop;
    // 启动协程
    auto task = my_async_job(loop);
    // 将协程包装成一个可执行任务并加入事件循环
    loop.schedule([&loop, task = std::move(task)]() mutable {
        // 由于我们使用的是std::suspend_never，协程已在这里完成
    });

    // 运行事件循环
    loop.run();
    return 0;
}

运行上述代码，你将看到：

Task start
Halfway through
Task finished

两次AsyncSleep之间大约延迟了1秒，证明协程挂起/恢复与事件循环协作顺利。

六、总结与展望

• 协程是把异步代码写成同步样式的强大手段。
• 通过awaitable与事件循环的组合，可以实现高度可组合的异步框架。
• 本示例极度简化，真正的IO协程需要结合系统层面的多路复用（epoll/kqueue）以及线程池等组件。

你可以进一步扩展：

• 使用std::future/std::promise包装协程返回值。
• 将事件循环改为多线程，支持并发调度。
• 对接网络套接字，实现真正的异步服务器。

C++20协程正在快速成熟，掌握它将为你开启更高效、更可维护的异步编程之路。祝你编码愉快！

模块（Modules）是 C++20 标准引入的核心特性之一，旨在解决传统头文件（#include）带来的诸多痛点。通过把接口（header）和实现（source）彻底分离，模块不仅显著缩短编译时间，还提升了代码可维护性和模块化程度。下面从背景、基本概念、实现方式以及常见问题四个方面，系统阐述 C++20 模块的使用与优势。

1. 背景：头文件的局限性

• 重复编译：每个翻译单元都会逐字复制被 #include 的头文件内容，导致大量冗余编译工作。
• 命名冲突：头文件中的全局符号容易产生冲突，尤其是大型项目或第三方库。
• 隐式依赖：编译器无法准确推断头文件的依赖关系，导致更高的编译成本与不必要的错误。
• 缺乏信息隐藏：所有符号默认可见，缺少模块级别的访问控制。

2. 基本概念

• 模块单元：由一个或多个源文件组成，声明模块名的文件（module fragment）使用 export module modulename; 语句开头。所有 export 语句的内容对外可见。
• 模块接口单元（interface unit）：唯一包含 export module modulename; 的文件，负责暴露模块的公共 API。
• 模块实现单元（implementation unit）：不含 export module 声明，内部实现细节不对外暴露，只能在接口单元内部使用。
• 导入（import）：类似 #include 的功能，但只加载模块一次，解析为二进制模块接口（MMI）文件。

3. 如何使用

3.1 结构示例

/project
├── lib
│   ├── math
│   │   ├── interface.hpp   // 传统头文件，用作辅助
│   │   ├── math.ixx        // 模块接口单元
│   │   └── math.cpp        // 模块实现单元
│   └── ...
└── app
    └── main.cpp

math.ixx

export module math;           // 模块名

export import <concepts>;     // 引入标准概念

export namespace math {
    template<typename T>
    requires std::is_arithmetic_v <T>
    T square(T x) {
        return x * x;
    }
}

math.cpp

module math;                  // 模块实现单元

namespace math {
    // 如果需要内部实现细节或私有函数
    static double log2(double x) {
        return std::log(x) / std::log(2.0);
    }
}

main.cpp

import math;                  // 导入模块

#include <iostream>

int main() {
    std::cout << "square(5) = " << math::square(5) << '\n';
    return 0;
}

3.2 编译步骤

# 先生成模块接口
g++ -std=c++20 -fmodules-ts -c lib/math/math.ixx -o math.mii
# 编译实现单元
g++ -std=c++20 -fmodules-ts -c lib/math/math.cpp -o math.o
# 编译应用程序
g++ -std=c++20 -fmodules-ts main.cpp math.o -o app

提示：不同编译器支持细节不同，-fmodules-ts 是 GCC、Clang 的实验性选项；MSVC 使用 /experimental:module。实际项目建议使用 CMake 配置，利用 add_library 和 target_link_libraries 自动处理模块文件。

4. 主要优势

1. 编译速度：模块只编译一次，后续翻译单元直接导入二进制接口，极大缩短编译时间，尤其对大型项目可提升 30%~50%。
2. 封装性：实现细节不对外泄露，只有显式 export 的符号才对外可见，提升代码安全性。
3. 并行编译：由于模块之间无重复编译，能更好地利用多核编译。
4. 类型安全：模块提供编译器级别的依赖关系解析，减少因头文件顺序错误导致的预编译错误。

5. 常见陷阱与解决方案

场景	问题	解决办法
模块间相互导入	形成循环依赖	避免直接导入，使用前向声明或拆分模块
与第三方库结合	库未发布模块	对第三方库生成兼容的 module 文件或使用 #include 作为桥梁
与旧代码共存	传统头文件与模块混用	通过 `export import
` 引入模块，保持接口统一
编译器兼容	仍在实验阶段	关注编译器更新日志，使用 CMake 统一编译配置

6. 结语

C++20 模块为 C++ 语言生态注入了新的活力，解决了长期困扰的头文件问题。虽然在实际项目中推广还需要克服兼容性与工具链落地的障碍，但随着编译器的成熟与社区生态的完善，模块无疑将成为现代 C++ 开发的标配。把握好模块化思维，既能提升编译效率，也能让代码更易维护，值得每个 C++ 开发者深入学习与实践。

在 C++20 标准中，std::span 作为一种轻量级的视图容器，提供了对连续存储元素的安全访问。它不拥有数据，而是仅持有对已有数据的引用和长度信息。本文将从概念、使用场景、实现细节以及常见错误三个方面，对 std::span 进行全面剖析，并给出实用的编码示例。

---

1. std::span 的基本概念

• 无所有权：std::span 只保存指针和大小，不会负责内存管理。
• 只读或可写：通过 `const std::span ` 实现只读视图，`std::span` 实现可写视图。
• 兼容容器：可以从 std::array、std::vector、C 数组以及任意可迭代范围构造。
• 安全：内部提供 subspan()、first()、last() 等成员函数，防止越界访问。

std::vector <int> vec{1,2,3,4,5};
std::span <int> s(vec);          // 对 vec 的非 const 视图
std::span<const int> cs(vec);   // 对 vec 的 const 视图

---

2. 常见使用场景

场景	说明
函数参数	允许传递任意长度的数组或容器，而不需要模板化，提升可读性
批量处理	对子数组进行排序、求和、统计等操作，避免复制
算法接口	兼容旧的 C API 或 STL 算法，保持接口一致
网络编程	处理数据缓冲区时，提供可切片的视图，减少拷贝

---

3. 编码示例

3.1 简单遍历

void print_span(std::span<const int> sp) {
    for (int v : sp) std::cout << v << ' ';
    std::cout << '\n';
}

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span <int> sp(arr, 5);
    print_span(sp);          // 输出：10 20 30 40 50
}

3.2 子视图与切片

auto sub = sp.subspan(1, 3);  // 取下标 1 开始的 3 个元素
print_span(sub);              // 输出：20 30 40

3.3 与 STL 算法配合

std::sort(sp.begin(), sp.end());   // 原地排序

---

4. 注意事项与常见错误

1. 生命周期
   std::span 必须确保所引用的数据在其生命周期内有效。若引用的是局部变量或已被销毁的容器，使用会导致悬空指针。

2. 空视图
   通过 `std::span

   empty;` 或 `std::span{nullptr, 0}` 创建空视图是合法的，但使用 `front()`、`back()` 会抛异常。

3. 多维数组
   std::span 只支持一维连续存储。若需要处理二维数组，需要使用 std::span<std::span<T>> 或自定义包装。

4. C++20 限制
   在旧编译器或使用 C++17 时，std::span 需要使用外部实现，例如 gsl::span。

---

5. 高级技巧

• 自定义类型：可以在自定义结构体中使用 std::span 作为成员，以实现对内部数据的可视化访问。

struct Matrix {
    std::vector <double> data;
    size_t rows, cols;

    std::span <double> row(size_t r) {
        return std::span <double>(&data[r * cols], cols);
    }
};

• 内存对齐：在需要高性能计算时，确保数据对齐后使用 std::span 可以与 SIMD 指令配合，提升吞吐量。

---

6. 结语

std::span 的出现，为 C++ 提供了一种简洁、安全、无负担的视图容器。它既可以替代传统的裸指针+长度组合，也可以作为容器间互操作的桥梁。掌握 std::span 的使用，不仅能让代码更具可读性，还能显著降低内存拷贝成本，是现代 C++ 开发者不可或缺的工具。

C++17 标准正式引入了 <filesystem> 头文件，为文件系统的交互提供了一套类型安全、可组合的 API。相较于传统的 POSIX stat/opendir、Windows FindFirstFile 等调用，std::filesystem 把文件系统的细节封装成了面向对象的接口，并且在多平台间保持一致的语义。本文从 API 设计、典型使用场景、性能注意点以及未来的演进等几个维度，对 std::filesystem 进行深入剖析，帮助开发者在实际项目中快速上手、规避常见坑点。

1. 核心概念与类型

1.1 路径（std::filesystem::path）

路径是文件系统交互的起点，path 类提供了对字符串路径的封装。它支持多种构造方式：

std::filesystem::path p1("/home/user");
std::filesystem::path p2("..\data");
std::filesystem::path p3 = std::filesystem::current_path();

path 的内部实现使用 std::string 或 std::wstring，取决于编译器平台。通过 generic_string()、wstring() 等成员函数可获取统一的 UTF-8/UTF-16 表示。

1.2 文件、目录与文件描述符

std::filesystem::file_type 枚举定义了文件类型：regular、directory、symlink、block、character 等。file_status 包含类型与权限信息，而 directory_entry 则代表目录中的一条记录，支持延迟获取信息。

1.3 迭代器与视图

std::filesystem::directory_iterator 与 recursive_directory_iterator 通过返回 directory_entry 对象实现文件遍历。迭代器满足 InputIterator 语义，可与 STL 算法如 std::find_if 搭配使用。

2. 常用 API 及示例

2.1 创建、删除、移动文件

std::filesystem::create_directory("logs");
std::filesystem::create_directories("logs/2024/02"); // 多级

std::filesystem::copy("src.txt", "dest.txt",
                      std::filesystem::copy_options::overwrite_existing);

std::filesystem::rename("old.txt", "new.txt");
std::filesystem::remove("temp.txt"); // 文件
std::filesystem::remove_all("tmp");  // 递归删除目录

2.2 路径操作

std::filesystem::path p = "/usr/bin/gcc";
std::cout << "文件名: " << p.filename() << '\n'; // gcc
std::cout << "父目录: " << p.parent_path() << '\n'; // /usr/bin

p += "extra";
std::cout << "扩展后: " << p << '\n'; // /usr/bin/gccextra

2.3 文件信息

auto status = std::filesystem::status("config.json");
std::cout << "大小: " << std::filesystem::file_size("config.json") << " 字节\n";
std::cout << "是否可读: " << ((status.permissions() & std::filesystem::perms::owner_read) != 0) << '\n';

2.4 递归遍历

for (auto const& dir_entry : std::filesystem::recursive_directory_iterator("src"))
{
    if (dir_entry.is_regular_file() && dir_entry.path().extension() == ".cpp")
        std::cout << dir_entry.path() << '\n';
}

3. 性能与系统差异

3.1 延迟查询 vs 预查询

directory_entry 对象在构造时会调用 symlink_status()（不跟随符号链接），而 status()（跟随）会额外触发一次系统调用。若仅需文件类型，使用 symlink_status() 更高效。

3.2 线程安全

C++17 规定 filesystem 的函数在不同线程间是可并发调用的，只要它们不修改同一路径。recursive_directory_iterator 的多线程并发迭代需要自己同步。

3.3 大文件与硬链接

file_size() 对于大文件会返回 uintmax_t，若文件大小超过 size_t 上限需使用 std::filesystem::file_size 的 uintmax_t 版本。硬链接的计数通过 hard_link_count() 获取。

4. 常见陷阱与调试技巧

场景	错误	解决方案
Windows 路径分隔符	使用 / 而非 \\	path 会自动转换，或者使用 generic_string()
复制文件时报错	目标已存在	先检查 exists()，或使用 copy_options::overwrite_existing
符号链接递归遍历	造成无限循环	在 recursive_directory_iterator 中指定 options::follow_directory_symlink 并手动记录已访问链接
大量文件遍历	内存泄漏	directory_iterator 按需加载，务必在使用完后释放（使用范围语句即可）

5. 与旧接口的互操作

对于已有的 boost::filesystem 项目，C++17 的 std::filesystem 与 boost::filesystem 兼容性高。只需改名：

namespace fs = std::filesystem; // 替代 boost::filesystem

若项目使用 POSIX stat/opendir，可以通过 std::filesystem::path 的 c_str() 转为 C 字符串，或者直接使用 std::filesystem::status() 替代 stat()。

6. 未来展望

C++20 在 `

` 上进一步细化，新增 `relative_path()`, `lexically_normal()`, `temp_directory_path()` 等实用函数。C++23 将继续完善权限、磁盘空间等属性的查询 API，并提供更细粒度的错误处理。开发者应关注标准化进度，逐步迁移到更完整的 `std::filesystem` 接口。 ## 结语 `std::filesystem` 的出现，使得跨平台文件操作变得简洁、可维护。它将原本繁琐且易出错的系统调用包装成面向对象的接口，极大降低了编码错误率。掌握它的核心概念、典型 API 以及性能细节，能够帮助你在 C++ 项目中更高效地处理文件系统相关需求。无论是构建构建系统、实现日志框架还是做文件监控，`std::filesystem` 都是不可或缺的工具。

概念是 C++20 中新增的一项语言特性，旨在为模板编程提供更严格、更可读的约束。它们让你能够在编译时指定模板参数必须满足的属性或行为，从而提升代码安全性、可维护性以及错误信息的清晰度。下面我们从定义、实现、典型应用以及未来展望四个角度，系统解析概念的核心价值。

一、概念的基本定义

概念（Concept）本质上是对类型或表达式的一组约束集合。与传统的 SFINAE（Substitution Failure Is Not An Error）技巧相比，概念让约束表达更直观、更接近自然语言。一个概念可以被用作模板参数的“预检查”，如果不满足则编译器会在实例化阶段报错，而不是产生难以理解的“模板错误”。

template<typename T>
concept Incrementable = requires(T a) {
    { ++a } -> std::same_as<T&>;
    { a++ } -> std::same_as <T>;
};

上述 Incrementable 概念检查类型 T 是否支持前置自增、后置自增操作，并且返回类型与预期匹配。

二、如何声明和使用概念

1. 声明概念：使用 concept 关键字，后接约束表达式。可以使用 requires 关键字或更简洁的参数列表语法。

template<typename T>
concept Sized = requires(T t) {
    { sizeof(t) } -> std::convertible_to<std::size_t>;
};

2. 在模板中使用：有两种方式，一是直接在模板参数列表中放置概念，二是通过 requires 子句显式约束。

// 方式一：直接约束
template<Sized T>
T add(T a, T b) {
    return a + b;
}

// 方式二：requires 子句
template<typename T>
requires Sized <T>
T add(T a, T b) {
    return a + b;
}

3. 组合概念：使用逻辑运算符 &&、||、! 将多个概念组合。

template<typename T>
concept Arithmetic = Integral <T> || FloatingPoint<T>;

template<typename T>
requires Arithmetic <T>
T square(T x) {
    return x * x;
}

三、概念的优势

传统方法	问题	概念解决方案
SFINAE	产生大量隐晦错误	产生精确、可读的错误信息
过度模板化	难以维护	约束明确，代码更易理解
运行时检查	性能损失	纯编译期检查，无运行时成本
代码重复	多个 enable_if	复用概念定义，减少重复

1. 编译器报错更友好

SFINAE 失败会导致编译器输出“模板参数不匹配”等泛泛之词。概念则会显示“未满足 Incrementable 的约束”，直接指出问题所在。

2. 提升代码可维护性

概念为模板参数提供“接口”，类似于传统面向对象中的抽象类。阅读代码时，开发者可立即看到哪些操作被要求实现。

3. 强类型检查

通过概念，你可以在编译期判断一个类型是否可用于某个算法或容器，从而避免不必要的运行时错误。

四、典型案例

4.1 容器约束

template<typename Container>
concept CArrayLike = requires(Container c) {
    { c.size() } -> std::convertible_to<std::size_t>;
    { c.begin() } -> std::input_iterator;
    { c.end() }   -> std::input_iterator;
};

template<CArrayLike C>
void print_elements(const C& c) {
    for (auto it = c.begin(); it != c.end(); ++it) {
        std::cout << *it << ' ';
    }
}

此函数可接受 std::vector、std::array、甚至自定义容器，只要它们满足 CArrayLike。

4.2 自定义算法与概念

template<typename Iterator>
concept ForwardIterator = requires(Iterator it) {
    { *it } -> std::convertible_to<typename Iterator::value_type>;
    { ++it } -> std::same_as<Iterator&>;
};

template<ForwardIterator It>
int sum(It begin, It end) {
    int total = 0;
    for (; begin != end; ++begin) {
        total += *begin;
    }
    return total;
}

这里的 sum 函数只适用于满足 ForwardIterator 的迭代器，避免错误的使用。

五、未来展望

C++20 引入概念是一次大规模的语言升级，为 C++ 继续保持“性能 + 灵活性”的优势奠定了基础。未来标准（C++23/C++26）计划进一步丰富概念的功能：

• 默认约束：允许在概念中设置默认类型或值，减少显式约束的冗余。
• 可组合的约束：提供更灵活的 and、or、not 运算符，支持链式调用。
• 概念的元编程：允许在概念内部使用模板元编程技术，提升约束的表达能力。

六、总结

C++20 的概念为模板编程带来了清晰、可读、强大的约束机制。它们像是为模板参数提供了“签名”，从而让编译器在实例化阶段立即捕捉错误，并在编译日志中给出明确提示。掌握概念后，你可以写出更安全、更易维护的泛型代码，并充分利用编译期检查的优势。正是这份静态安全性，让 C++ 在性能和灵活性之间找到了新的平衡。