standrad c++

在 C++20 中引入的概念（Concepts）为模板编程提供了一套强大的语义工具。相比于传统的 SFINAE（Substitution Failure Is Not An Error）技巧，概念使得模板参数的约束更加直观、可读且编译时错误信息更加友好。本文将通过概念的基本语法、典型使用场景以及对编译性能与可维护性的影响，帮助你在实际项目中快速上手并充分利用概念带来的优势。

1. 概念的核心思想

概念是对模板参数类型或值的约束规则。它类似于函数签名中的参数类型，但更加灵活，支持对类型成员、运算符、常量等进行限制。使用概念可以：

• 提高代码可读性：约束规则与函数签名放在一起，减少了隐藏的编译错误。
• 减少编译错误信息的噪音：编译器在检测不满足约束时会给出明确的概念名称，而不是一连串的 SFINAE 消息。
• 提升编译性能：因为约束检查可以在实例化之前完成，避免了无效实例化。

2. 基本语法

2.1 定义概念

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

• requires 子句中列出表达式，右侧的 -> 用来指定返回类型（可选）。
• std::same_as 是 C++20 标准库中的概念，用于检查返回类型是否完全相同。

2.2 在函数模板中使用

template<Incrementable T>
T add_one(T value) {
    return ++value;
}

如果 T 不满足 Incrementable，编译器会给出 Incrementable 约束未满足的错误。

2.3 组合概念

template<typename T>
concept SignedInteger = std::integral <T> && requires(T x, T y) { x + y; } && std::signed_integral<T>;

template<SignedInteger T>
T multiply(T a, T b) { return a * b; }

3. 常见的标准库概念

概念	描述
`std::integral
`	T 是整数类型
`std::floating_point
`	T 是浮点类型
std::derived_from<Base, T>	T 继承自 Base
std::same_as<T1, T2>	两类型完全相同
`std::is_default_constructible
`	T 可默认构造
`std::is_copy_constructible
`	T 可拷贝构造
std::invocable<F, Args...>	F 可被调用，且参数 Args… 可传递

4. 应用场景

4.1 迭代器概念

C++20 标准中提供了 std::input_iterator, std::output_iterator 等概念。你可以在算法中使用这些概念来限制迭代器类型。

template<std::input_iterator It>
auto sum(It first, It last) {
    using Value = typename std::iter_value_t <It>;
    Value total{};
    for (; first != last; ++first) total += *first;
    return total;
}

4.2 适配器模式

使用概念来限制适配器的接口，从而确保所有适配器遵循统一的协议。

template<typename Adapter>
concept ReadableAdapter = requires(Adapter a, char* buf, std::size_t n) {
    { a.read(buf, n) } -> std::same_as<std::size_t>;
};

template<ReadableAdapter A>
void dump_to_stdout(A&& adapter) {
    char buffer[1024];
    std::size_t n;
    while ((n = adapter.read(buffer, sizeof(buffer))) > 0) {
        std::fwrite(buffer, 1, n, stdout);
    }
}

4.3 函数式编程与通用算子

借助概念，你可以编写更安全、更直观的高阶函数。

template<std::invocable F, typename T>
auto map(F f, const std::vector <T>& vec) {
    std::vector<std::invoke_result_t<F, T>> result;
    result.reserve(vec.size());
    for (const auto& v : vec) result.push_back(f(v));
    return result;
}

5. 对编译性能与可维护性的影响

• 编译性能：概念的检查发生在模板实例化前，编译器可以更早地过滤掉不合法的模板实例，从而减少不必要的编译工作。特别是在大规模代码库中，这种提前过滤能够显著提升整体编译时间。
• 错误信息友好：标准库提供的概念本身带有含义明确的错误提示，避免了传统 SFINAE 中难以理解的错误链条。
• 可维护性提升：约束规则集中在概念定义处，而不是分散在各个模板函数内部，使得代码结构更清晰，维护成本降低。

6. 实践建议

1. 先定义概念：在实现算法之前先确定相关概念，尤其是在需要对类型进行严格约束的场景。
2. 使用标准概念：尽量复用标准库提供的概念，减少自定义概念的数量。
3. 逐步提升：先使用基本概念（如 std::integral），再根据需要添加更细粒度的约束。
4. 保持简洁：概念的表达式要尽量简短、直观，避免过度复杂导致编译器错误难以定位。

7. 结语

C++20 的概念为模板元编程带来了全新的语义层次。通过清晰、可组合的约束规则，开发者可以写出既强大又可维护的模板代码。掌握概念的使用，将是提升 C++ 代码质量和开发效率的重要技能。祝你在模板编程的道路上越走越顺畅！

在C++中，单例模式（Singleton Pattern）是一种常用的设计模式，用来确保一个类只有一个实例，并提供全局访问点。实现线程安全的单例模式是一项挑战，尤其是在多线程环境下，需要保证实例在并发访问时不被多次创建。下面介绍几种常见的实现方式，并比较其优缺点。

1. 经典双重检查锁定（Double-Checked Locking, DCL）

class Singleton {
public:
    static Singleton& getInstance() {
        if (instance_ == nullptr) {                 // 第一次检查
            std::lock_guard<std::mutex> lock(mutex_);
            if (instance_ == nullptr) {             // 第二次检查
                instance_ = new Singleton();
            }
        }
        return *instance_;
    }

    // 禁止拷贝构造和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

    static Singleton* instance_;
    static std::mutex mutex_;
};

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mutex_;

优点

• 只在第一次创建实例时获取锁，后续访问无需锁，性能较好。

缺点

• 需要使用volatile或std::atomic以避免编译器优化导致的可见性问题（C++11之后，std::atomic已解决）。
• 代码相对繁琐，容易出错。

2. Meyers 单例（函数内部静态变量）

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;   // 线程安全的局部静态变量
        return instance;
    }

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

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

优点

• 简单、易读。
• 自C++11起，局部静态变量的初始化是线程安全的，遵循”线程安全的初始化”（call_once内部实现）。

缺点

• 不能延迟销毁：如果在main函数退出时，单例的析构顺序与其他全局对象可能产生依赖。
• 对于极度受限的环境（如嵌入式）可能不适合。

3. std::call_once 与 std::once_flag

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

    // 需要手动释放
    static void destroy() {
        delete instance_;
        instance_ = nullptr;
    }

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

优点

• 明确控制实例的创建时机。
• call_once 只在第一次调用时执行初始化代码，后续调用不再锁。

缺点

• 需要手动释放内存，或者让实例成为std::unique_ptr，否则会导致内存泄漏。
• 代码比Meyers略显繁琐。

4. 通过 std::shared_ptr 实现懒加载

class Singleton {
public:
    static std::shared_ptr <Singleton> getInstance() {
        std::call_once(initFlag_, [](){
            instance_ = std::shared_ptr <Singleton>(new Singleton());
        });
        return instance_;
    }

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

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

    static std::shared_ptr <Singleton> instance_;
    static std::once_flag initFlag_;
};

std::shared_ptr <Singleton> Singleton::instance_ = nullptr;
std::once_flag Singleton::initFlag_;

优点

• 采用智能指针管理生命周期，避免手动删除。
• 与多线程环境配合良好。

缺点

• 需要 C++11 标准库支持。
• 如果全局对象在程序结束时销毁，仍可能出现析构顺序问题。

5. 线程局部存储（Thread-Local Singleton）

如果你想为每个线程提供独立的单例实例，可使用 thread_local：

class ThreadSingleton {
public:
    static ThreadSingleton& getInstance() {
        thread_local ThreadSingleton instance;
        return instance;
    }

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

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

优点

• 每个线程有自己的实例，避免竞争。
• 初始化与销毁都在线程生命周期内完成。

缺点

• 不是真正意义上的“全局单例”，如果你需要全局唯一对象，这种方式不合适。

小结

• 最简洁：Meyers 单例（局部静态变量）是最推荐的实现方式，尤其在 C++11 之后。
• 可定制：如果你需要更细粒度的初始化控制，std::call_once 是更好的选择。
• 多线程安全：所有实现都在 C++11 标准库中使用原子操作和锁，确保线程安全。

在实际项目中，建议先尝试使用 Meyers 单例，除非有特殊需求（如需要显式销毁或跨模块的初始化顺序），再考虑其他实现方案。

单例模式的核心在于确保一个类只有一个实例，并提供全局访问点。随着 C++11 及其后的标准引入了多线程支持，传统的单例实现方式（如饿汉式、懒汉式）需要额外的同步机制来保证线程安全。下面介绍几种常见且高效的实现方法，并对比其优缺点。

1. 局部静态变量（Meyers Singleton）

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;   // C++11 guarantees thread-safe initialization
        return instance;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

• 优点：实现最简洁，编译器负责线程安全。无显式锁，性能优良。
• 缺点：如果你想在程序结束前显式销毁单例，需要自定义 std::atexit 或使用 std::unique_ptr 包装。

2. 带双重检查锁（Double-Checked Locking）

class Singleton {
public:
    static Singleton* getInstance() {
        Singleton* tmp = instance.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mtx);
            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 mtx;
};

std::atomic<Singleton*> Singleton::instance{nullptr};
std::mutex Singleton::mtx;

• 优点：延迟初始化，且线程安全。
• 缺点：实现相对复杂，易出错。现代编译器和标准库的实现已经足够优雅，通常不需要手动实现。

3. 显式销毁的懒汉式（使用 std::unique_ptr）

class Singleton {
public:
    static Singleton& getInstance() {
        std::call_once(initFlag, []{
            instance.reset(new Singleton);
        });
        return *instance;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

    static std::unique_ptr <Singleton> instance;
    static std::once_flag initFlag;
};

std::unique_ptr <Singleton> Singleton::instance;
std::once_flag Singleton::initFlag;

• 优点：支持在程序退出时显式销毁，避免懒汉式带来的“野指针”问题。
• 缺点：需要 `#include `、“，但实现仍然较为简洁。

4. 静态局部对象与 std::shared_ptr（可定制生命周期）

如果你想让单例对象在多处持有引用，可以结合 std::shared_ptr：

class Singleton {
public:
    static std::shared_ptr <Singleton> getInstance() {
        static std::shared_ptr <Singleton> ptr(new Singleton, [](Singleton* p){ delete p; });
        return ptr;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

• 优点：可以通过引用计数控制对象的生命周期，适用于需要在多线程环境中共享实例的场景。
• 缺点：若不小心产生循环引用，可能导致资源泄漏。

5. 线程安全的双向单例（双重初始化 + 读写锁）

在高并发读多写少的场景下，读写锁可以提升性能：

class Singleton {
public:
    static Singleton* getInstance() {
        std::shared_lock<std::shared_mutex> rlock(rwMutex);
        if (!instance) {
            rlock.unlock();
            std::unique_lock<std::shared_mutex> wlock(rwMutex);
            if (!instance) {
                instance = new Singleton;
            }
            rlock.lock();
        }
        return instance;
    }

private:
    static Singleton* instance;
    static std::shared_mutex rwMutex;
};

Singleton* Singleton::instance = nullptr;
std::shared_mutex Singleton::rwMutex;

• 优点：多线程读操作不阻塞，写操作仍然保证安全。
• 缺点：实现较为复杂，且在实例化后不再需要写锁，可能导致不必要的锁开销。

---

何时选择哪种实现？

实现方式	适用场景	主要优势	主要缺点
局部静态变量	简单、无销毁需求	代码最简洁，编译器自动线程安全	不能显式销毁
std::call_once + unique_ptr	需要显式销毁	线程安全，资源可被清理	需要额外头文件
双重检查锁	兼容旧编译器	延迟初始化	实现复杂，潜在错误
shared_ptr	需要共享实例	自动管理生命周期	可能出现循环引用
读写锁	读多写少	高并发读	复杂，写锁开销

在大多数现代 C++ 项目中，局部静态变量（Meyers Singleton）已成为默认首选，因为它实现最简洁、性能最优，并且在 C++11 之后已被标准保证线程安全。只有在特殊需求（如显式销毁、共享实例或读写锁优化）下才考虑其他实现。

小结

• 线程安全：C++11 引入的局部静态变量或 std::call_once 可轻松实现。
• 延迟初始化：如果想避免在程序启动时就实例化，可以使用 std::call_once。
• 生命周期管理：若需要在程序结束前释放资源，考虑 std::unique_ptr 或 std::shared_ptr。
• 性能考虑：在多线程读多写少的场景下，读写锁可进一步提升性能，但要权衡实现复杂度。

通过以上方法，你可以根据项目需求灵活选择最合适的单例实现方案，确保代码既简洁又安全。

在 C++20 标准正式发布后，协程（coroutine）这一强大功能被正式纳入语言核心。协程允许程序员用更直观的方式书写异步代码，隐藏了事件循环的细节，使得代码可读性与可维护性大幅提升。本文将从基本概念出发，介绍协程的核心组成，演示如何实现一个简单的异步流，并结合文件 I/O 示例演示实际应用场景。

---

1. 协程基础概念

1.1 协程与线程的区别

• 协程：协作式多任务，执行上下文在同一线程内切换。协程暂停点是显式的（如 co_await），需要调度器手动切换。
• 线程：抢占式多任务，操作系统调度多核并行执行。线程上下文切换成本较高，且同步复杂度高。

协程在 I/O 密集型或需要大量状态机的场景下表现优异。

1.2 协程的三大核心组件

1. promise_type：协程的承诺类型，定义协程返回值、异常处理以及生命周期管理。
2. handle：协程句柄，用于管理协程的生命周期，启动、暂停、恢复、销毁。
3. awaitable：可等待对象，提供 await_ready()、await_suspend()、await_resume() 三个成员函数，决定协程何时挂起、恢复以及返回结果。

---

2. 协程的基本语法

// 1. 定义 awaitable 对象
struct TimerAwaitable {
    std::chrono::milliseconds duration;
    std::promise <void> prom;

    bool await_ready() { return duration.count() == 0; }
    void await_suspend(std::coroutine_handle<> h) {
        std::thread([=, h]() mutable {
            std::this_thread::sleep_for(duration);
            prom.set_value();
            h.resume();
        }).detach();
    }
    void await_resume() {}
};

// 2. 定义协程函数
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

Task async_operation() {
    std::cout << "Start\n";
    co_await TimerAwaitable{std::chrono::milliseconds(1000)};
    std::cout << "After 1s\n";
}

上述示例展示了一个简单的协程函数 async_operation，通过 co_await 暂停 1 秒后继续执行。

---

3. 实现一个异步流（Async Stream）

3.1 需求分析

我们想要实现一个能够异步读取文件内容的流式接口，类似于 JavaScript 的 ReadableStream。读者可以使用 co_await 或循环 while 来逐块读取数据。

3.2 设计思路

• ChunkSize：每次读取的字节数，默认 4096。
• AsyncFileReader：协程类，内部维护文件指针与缓冲区。
• awaitable：ReadAwaitable 用于实现 co_await，在后台线程读取文件内容后返回给协程。

3.3 关键实现

#include <coroutine>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>

class AsyncFileReader {
public:
    struct promise_type;
    using handle_type = std::coroutine_handle <promise_type>;

    struct promise_type {
        AsyncFileReader get_return_object() {
            return AsyncFileReader{handle_type::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

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

    // awaitable for reading next chunk
    struct ReadAwaitable {
        std::string& buffer;
        std::ifstream& file;
        std::size_t chunkSize;

        bool await_ready() const noexcept { return false; }

        void await_suspend(std::coroutine_handle<> h) {
            std::thread([=, h]() mutable {
                buffer.resize(chunkSize);
                file.read(buffer.data(), static_cast<std::streamsize>(chunkSize));
                std::size_t readSize = static_cast<std::size_t>(file.gcount());
                buffer.resize(readSize); // shrink to actual size
                h.resume();
            }).detach();
        }

        std::string await_resume() { return buffer; }
    };

    // Interface to fetch next chunk
    ReadAwaitable read_next(std::size_t chunkSize = 4096) {
        return ReadAwaitable{buf, file, chunkSize};
    }

private:
    handle_type coro;
    std::ifstream file{ "sample.txt", std::ios::binary };
    std::string buf;
};

async Task read_file_stream() {
    AsyncFileReader reader{ };
    while (!reader.file.eof()) {
        std::string chunk = co_await reader.read_next();
        if (chunk.empty()) break;
        std::cout << "Chunk (" << chunk.size() << " bytes): " << chunk << "\n";
    }
}

说明：

• AsyncFileReader 在构造时打开文件，并提供 read_next 方法返回一个 awaitable。
• ReadAwaitable 在后台线程中执行 file.read，完成后恢复协程。
• 读者可以在自己的协程中使用 while 循环 co_await read_next，实现流式读取。

3.4 使用示例

int main() {
    std::cout << "Async file read started\n";
    auto coro = read_file_stream();
    // 直接运行协程
    // 若有事件循环，可将其挂载至事件循环
    return 0;
}

此程序会在后台线程中读取文件，主线程不会被阻塞。通过 co_await 的方式，代码保持了同步式的可读性。

---

4. 进阶：协程与网络 I/O

在网络编程中，协程常用于实现非阻塞套接字。大多数现代网络库（如 Boost.Asio、cppcoro、libuv 的 C++ 封装）都已经提供了协程支持。使用协程可以把异步回调链转化为顺序式代码。

asio::ip::tcp::socket socket{io_context};
co_await socket.async_connect({ip, port}, asio::use_awaitable);
co_await socket.async_send(asio::buffer(msg), asio::use_awaitable);
std::array<char, 1024> buf;
std::size_t n = co_await socket.async_receive(asio::buffer(buf), asio::use_awaitable);

上述代码不需要显式回调函数，协程自动在网络 I/O 完成后恢复执行。

---

5. 结语

C++20 的协程为编写高性能、可维护的异步代码提供了语言级支持。通过 promise_type、awaitable 以及 coroutine_handle 等机制，协程可以轻松实现文件 I/O、网络通信以及任何需要状态机的场景。虽然协程的实现细节仍有一定的学习成本，但一旦掌握后，其代码结构会变得更加直观，错误率显著降低。

在实际项目中，建议先熟悉协程的基础用法，然后逐步尝试结合第三方库（如 Boost.Asio）实现更复杂的异步业务。随着标准的完善与生态的丰富，C++协程将成为高性能服务器、游戏引擎以及嵌入式系统中的重要工具。祝你在协程之旅中收获丰硕成果！

协程是C++20引入的语言特性，它为编写异步代码提供了更直观、更高效的方式。相比传统的回调或状态机，协程可以让代码保持同步的写法，却在运行时实现非阻塞等待。本文将通过实现一个最小化的异步任务调度器来演示协程的基本用法，并解释关键概念与实现细节。

1. 协程基础回顾

1.1 协程的核心概念

• 协程函数：使用co_await、co_yield或co_return的函数被视为协程。它们的返回类型必须是std::future、std::generator或自定义的awaitable等协程特化类型。
• 协程句柄 (std::coroutine_handle): 用来控制协程的生命周期（resume、destroy等）。
• Suspension（挂起）: co_await和co_yield会导致协程挂起，暂停执行直到外部恢复。

1.2 典型用例

• I/O 事件驱动：异步读取文件、网络等
• 任务并行：在单线程内分配多任务执行
• 状态机简化：用协程替代手写状态机逻辑

2. 设计目标

• 易用：只需要调用 async_task() 就能获得一个可等待的对象。
• 低开销：使用内置的 std::coroutine_handle，避免额外的线程池或调度线程。
• 可扩展：支持简单的任务链、错误传播和取消机制。

3. 核心组件实现

3.1 Awaitable 结构

template<typename T = void>
class Awaitable {
public:
    struct promise_type {
        std::coroutine_handle <promise_type> coro_handle;
        T value;
        std::exception_ptr eptr;

        Awaitable get_return_object() {
            return Awaitable{std::coroutine_handle <promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }

        void return_value(T v) { value = std::move(v); }
        void unhandled_exception() { eptr = std::current_exception(); }
    };

    using handle_type = std::coroutine_handle <promise_type>;

    explicit Awaitable(handle_type h) : handle(h) {}
    ~Awaitable() { if (handle) handle.destroy(); }

    // 让外部代码可以等待协程
    T await_resume() {
        if (handle.promise().eptr) std::rethrow_exception(handle.promise().eptr);
        return std::move(handle.promise().value);
    }

    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<> awaiting) {
        // 这里简单地把协程挂起，稍后在外部 resume
        awaiting.resume();
    }

    handle_type handle;
};

3.2 简易调度器

调度器维护一个任务队列，每个任务是 Awaitable 对象。通过 std::deque 或 std::queue 来存储，使用 std::function<void()> 作为任务包装。

class SimpleScheduler {
public:
    void post(auto&& awaitable) {
        tasks.emplace_back([awaitable = std::move(awaitable)]() mutable {
            awaitable.handle.resume();
        });
    }

    void run() {
        while (!tasks.empty()) {
            auto task = std::move(tasks.front());
            tasks.pop_front();
            task();
        }
    }

private:
    std::deque<std::function<void()>> tasks;
};

3.3 async_task 辅助函数

template<typename Func>
auto async_task(Func&& f) {
    struct Awaiter {
        std::coroutine_handle<> caller;
        std::future<decltype(f())> fut;
    };

    return Awaitable<decltype(f())>{ 
        [](Func f) -> Awaitable<decltype(f())> {
            co_await std::async(std::launch::async, f);
            co_return f();
        }(std::forward <Func>(f))
    };
}

上述示例演示了将普通函数包裹成协程的方式；实际可根据需求定制不同的 Awaitable 版本。

4. 使用示例

SimpleScheduler scheduler;

awaitable <int> compute_task() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时计算
    co_return 42;
}

awaitable <void> main_task() {
    int result = co_await compute_task();
    std::cout << "Result: " << result << std::endl;
}

int main() {
    scheduler.post(main_task());
    scheduler.run();
    return 0;
}

运行后会在 2 秒后打印 Result: 42。整个流程没有使用多线程，协程在单线程内按需挂起与恢复。

5. 进阶改进

1. 错误传播：在 promise_type::unhandled_exception() 中捕获异常，允许外部 await_resume() 通过 std::rethrow_exception 处理。
2. 取消机制：在 promise_type 中添加 `std::atomic cancelled`，在 `await_suspend` 检查是否已取消。
3. 多任务并行：将调度器改为事件循环模式，利用 std::condition_variable 让任务按需被唤醒。

6. 小结

协程为 C++ 提供了一种更自然的异步编程模型。通过本示例，我们构建了一个最小化的异步任务调度器，演示了协程的挂起、恢复与结果返回。虽然示例代码简洁，但它涵盖了协程使用的核心要点，为后续更复杂的异步框架（如 libuv、Boost.Asio 等）奠定了理解基础。希望能帮助你在 C++ 项目中顺利采用协程技术。

在过去的 C++ 发展历程中，模板编程以其强大的类型擦除和高效的编译期计算能力，成为了实现泛型编程的核心工具。然而，随着模板代码越来越复杂，常常会出现编译错误难以定位、文档不完整以及使用者误用模板等问题。C++20 引入的“概念”（Concepts）为这些痛点提供了系统性的解决方案。本文将从概念的基本语义、实现方式、典型使用案例以及未来发展方向四个方面，探讨概念如何提升模板编程的可读性与安全性。

1. 概念的基本语义

概念是一种对类型或表达式进行约束的机制，类似于模板参数的“前置条件”。它们在编译期对模板参数进行检查，如果不满足约束，编译器会给出更友好的错误信息。概念的核心特性包括：

• 类型约束：使用 typename T 或 auto 前置参数，随后在概念体中使用 requires 关键字定义条件。
• 表达式约束：利用 requires 子句内的表达式检查类型是否支持特定运算符或成员函数。
• 组合与继承：概念可以继承或组合其他概念，实现层次化约束。
• 可组合性：概念可以像函数参数那样被重用，提升代码复用度。

2. 概念如何实现模板检查

在 C++20 之前，模板错误往往隐含在实例化链中，错误信息散落于编译器生成的多层信息。概念通过显式约束使错误定位变得直观：

template<typename T>
concept Incrementable = requires(T x) {
    ++x; // 前置递增
    x++; // 后置递增
};

template<Incrementable T>
void increment(T& val) {
    ++val;
}

若 T 不满足 Incrementable，编译器将直接提示“Incrementable”概念未满足，而不是在实例化 increment 时产生模糊错误。

3. 典型使用案例

3.1 结构化绑定与 std::tuple_size

C++20 允许使用概念对 std::tuple_size 进行约束，以确保类型可以解包：

template<typename T>
concept TupleLike = requires(T t) {
    std::tuple_size <T>::value;
};

template<TupleLike T>
auto sum_tuple(const T& t) {
    return std::apply([](auto&&... args) { return (args + ...); }, t);
}

3.2 函数对象与 std::invocable

std::invocable 是一个标准概念，用于检查可调用对象是否满足某种签名：

template<typename F, typename... Args>
concept Invocable = requires(F f, Args&&... args) {
    std::invoke(f, std::forward <Args>(args)...);
};

使用 Invocable 可以在 std::async 或 std::thread 之类的库函数中进行更严格的编译期检查。

3.3 统一容器访问

通过定义 Container 概念，统一 std::vector、std::list、std::array 等容器：

template<typename C>
concept Container = requires(C c, typename std::decay_t <C>::value_type v) {
    c.begin();
    c.end();
    *c.begin() == v;
};

随后在函数模板中使用 Container，即可接受任意满足该概念的容器类型。

4. 概念提升可读性的细节

• 自文档化：概念名称往往自带语义，如 Incrementable、CopyConstructible，读者可以立即理解限制。
• 编译期诊断：错误信息更加精准，避免了“模板不匹配”堆栈式错误。
• 类型推导清晰：在模板参数列表中直接列出概念，减少了隐式类型推导带来的歧义。

5. 概念的未来发展

• 标准库进一步集成：更多标准库容器和算法将使用概念进行约束，如 std::ranges 的 input_range、forward_range 等。
• 第三方库的落地：Boost、STLPort 等库将引入概念以提高接口鲁棒性。
• IDE 与编译器的支持：更好的错误提示、代码补全和静态分析工具将围绕概念展开，进一步提升开发体验。

6. 结语

概念为 C++ 的模板编程注入了“类型安全”与“可读性”两种关键维度。通过在模板参数处明确定义约束，开发者可以在编译期捕获错误、提高代码的可维护性，并让接口更具自解释性。C++20 的概念只是起点，随着标准库和第三方库的逐步采用，未来的 C++ 代码将会更加安全、可读且易于协作。

constexpr 关键字在 C++17 进一步提升了其功能，允许在编译期执行更复杂的计算，甚至支持递归函数、循环以及条件语句。借助 constexpr，程序员可以把常量表达式移到编译阶段，从而减小运行时开销、提高代码安全性，并为模板元编程提供更直观的实现手段。以下从几个角度详细阐述 constexpr 的新特性及其应用场景。

1. 递归与循环的 constexpr
C++11 的 constexpr 只能使用单一返回语句，且不支持递归。C++14 放宽了这一限制，允许递归函数和循环体。C++17 在此基础上进一步加强，支持更灵活的递归逻辑和复杂的循环结构。示例：

constexpr unsigned int factorial(unsigned int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
static_assert(factorial(5) == 120, "阶乘错误");

通过 constexpr，编译器在编译时就算出了 5 的阶乘，生成的代码中不再包含递归函数调用。

2. constexpr if
if constexpr 语句是 C++17 的一大亮点。它在编译时根据条件决定哪一条分支被实例化，未被实例化的分支甚至不需要满足语法正确性。常用于模板元编程，实现更简洁的 SFINAE 替代方案。示例：

template<typename T>
constexpr void printType() {
    if constexpr (std::is_integral_v <T>) {
        std::cout << "Integral\n";
    } else if constexpr (std::is_floating_point_v <T>) {
        std::cout << "Floating point\n";
    } else {
        std::cout << "Other\n";
    }
}

此处，编译器会根据模板参数的类型选择合适的分支，其他分支在编译时被忽略，避免了潜在的类型错误。

3. 编译期容器
C++17 引入了 constexpr std::vector、constexpr std::array 等容器的改进，允许在编译期进行容器的初始化与访问。虽然标准库并未对所有容器做 constexpr 支持，但自定义的 constexpr 容器成为可行方案。

template<std::size_t N>
struct ConstExprArray {
    std::array<int, N> data{};
    constexpr int operator[](std::size_t i) const { return data[i]; }
    constexpr void set(std::size_t i, int val) { data[i] = val; }
};
constexpr ConstExprArray <5> arr{{1, 2, 3, 4, 5}};
static_assert(arr[2] == 3, "编译期访问错误");

4. 编译期错误检查
通过 static_assert 与 constexpr 结合，可以在编译期捕获逻辑错误。例如验证数组索引是否越界，或者检查数值范围：

constexpr int safe_div(int a, int b) {
    static_assert(b != 0, "除数不能为零");
    return a / b;
}

5. 与模板元编程的协同
constexpr 与模板元编程天然契合。借助 constexpr，可以在编译期计算复杂值，减少模板实例化时的计算量。例如实现一个在编译期计算斐波那契数列的函数：

template<std::size_t N>
constexpr unsigned long long fib() {
    return N <= 1 ? N : fib<N-1>() + fib<N-2>();
}
static_assert(fib <10>() == 55, "斐波那契错误");

此类实现既简洁又安全，所有计算都在编译阶段完成。

结语
C++17 的 constexpr 与编译期计算功能，为程序员提供了强大的工具，使得代码既可以在运行时高效，又能在编译期进行严谨检查。无论是提升性能、减少运行时错误，还是简化模板元编程，constexpr 都是不可或缺的技术手段。随着标准进一步演进，constexpr 的应用场景将更加广泛，为 C++ 的可维护性与高效性打开新的维度。

在现代 C++（C++11 及以后）中，实现线程安全的单例模式其实比以往更为简洁。核心思路是利用 局部静态变量 的特性——其初始化是线程安全的，并且只会在第一次进入作用域时执行一次。下面我们从头到尾展示一个完整的实现，并剖析其内部细节、性能考量以及常见误区。

1. 传统单例实现回顾

class ClassicSingleton {
public:
    static ClassicSingleton& instance() {
        if (!m_instance) {
            m_instance = new ClassicSingleton();
        }
        return *m_instance;
    }
    // 其他业务方法...
private:
    ClassicSingleton() {}
    ClassicSingleton(const ClassicSingleton&) = delete;
    ClassicSingleton& operator=(const ClassicSingleton&) = delete;

    static ClassicSingleton* m_instance;
};

ClassicSingleton* ClassicSingleton::m_instance = nullptr;

这个实现存在几个明显问题：

• 线程安全：m_instance 的懒加载不是原子操作，多个线程可能同时创建实例。
• 内存泄漏：没有显式释放 m_instance，程序退出时才会自动释放，或者需要在 atexit 中手动释放。
• 性能：每次访问 instance() 都要检查指针是否为空，且 new 操作带来不必要的开销。

2. C++11 局部静态变量实现

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;   // 线程安全的局部静态变量
        return instance;
    }

    // 示例业务方法
    void do_something() { std::cout << "Doing something\n"; }

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

    // 禁止拷贝与赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

关键点说明

1. 线程安全的初始化
   C++11 标准保证局部静态变量的初始化是 按需、线程安全的。编译器会自动插入必要的锁或使用原子操作，确保即使多个线程同时调用 instance()，也只会构造一次 Singleton。

2. 无内存泄漏
   该对象的生命周期与程序相同：构造时在栈上分配，程序结束时自动销毁，避免手动 delete 的麻烦。

3. 性能优势
   第一次调用时的初始化成本不算大，后续调用仅返回已有对象，无需额外锁或判断。由于初始化仅发生一次，开销极小。

3. 进一步优化：懒加载 vs 预加载

• 懒加载（上面示例）：只在第一次真正使用时才创建。适合实例化成本高或不确定是否会使用的单例。
• 预加载：在程序启动时就创建单例，避免后续多线程竞争导致的短暂停顿。

class PreloadSingleton {
public:
    static PreloadSingleton& instance() {
        return *s_instance;
    }
private:
    PreloadSingleton() { std::cout << "Preloaded\n"; }
    ~PreloadSingleton() {}
    static PreloadSingleton* s_instance;

    friend void init_preload();  // 由外部函数初始化
};

PreloadSingleton* PreloadSingleton::s_instance = nullptr;

void init_preload() {
    PreloadSingleton::s_instance = new PreloadSingleton();
}

调用 init_preload() 可以放在 main() 或 DllMain 等入口点，保证单例提前创建。

4. 常见误区

1. 错误的宏替换
   许多人用 #define SINGLETON(...) 宏来创建单例，但宏不具备类型安全和作用域控制，容易导致名字冲突。

2. 忘记 delete 关键字
   在 C++11 之前，常用 static Singleton* instance; 并手动 delete，容易出现野指针或多次删除。

3. 忽视异常安全
   如果构造函数抛异常，局部静态变量会被销毁并重新尝试构造，直到成功为止。若不想重复构造，可捕获异常并手动控制。

5. 适用场景举例

• 日志系统：全局唯一日志记录器，避免多实例写冲突。
• 配置管理：一次读取配置文件，随后所有模块共享同一实例。
• 线程池：全局线程池实例，避免多线程创建不必要的线程。

6. 小结

• C++11 之后，使用局部静态变量即可实现线程安全的单例，代码简洁且性能优秀。
• 对于特殊需求（提前创建、异常处理）可以结合手动初始化或自定义锁实现。
• 牢记禁止拷贝与赋值，保持单例唯一性。

单例模式在 C++ 中既是设计模式的经典，也展示了语言标准如何在细节层面帮助我们写出安全、简洁的代码。只要把握好上述要点，即可在项目中自如运用。

在C++20中引入的 Modules 概念为大规模项目的编译速度、可维护性和代码可重用性提供了全新的解决方案。下面以一个典型的图形渲染引擎为例，逐步展示如何把项目拆分成模块、编译和链接，以及如何避免常见的陷阱。

1. 为什么要使用 Modules？

• 编译速度提升：传统的头文件方式会产生大量重复编译。Modules 只编译一次，生成编译单元（.ifc 文件）供其他文件共享。
• 命名空间冲突减少：模块内部的名字不再是全局可见，降低冲突风险。
• 隐藏实现细节：通过 export 关键字只暴露必要的接口，隐藏实现细节更容易维护。

2. 项目结构示例

/rendering
    /core
        core.module
        Mesh.hpp
        Mesh.cpp
    /shaders
        shader.module
        VertexShader.hpp
        FragmentShader.hpp
    /utils
        utils.module
        Math.hpp
        Math.cpp
    main.cpp

• 每个子目录对应一个模块。
• module 文件（如 core.module）是模块的入口点，列出需要导出的头文件。

3. 编写模块文件

以 core.module 为例：

// core.module
export module core;
export * from "Mesh.hpp";

• export module core; 声明模块名。
• export * from "Mesh.hpp"; 把 Mesh.hpp 的内容导出给外部使用。

4. 编译单独模块

假设使用 GCC 12+ 或 Clang 14+，可以这样编译：

# 编译 core 模块
g++ -std=c++20 -fmodules-ts -c Mesh.cpp -o core.ifc

# 编译 shaders 模块
g++ -std=c++20 -fmodules-ts -c VertexShader.cpp -o shaders.ifc

注意：-fmodules-ts 选项开启模块实验特性。不同编译器实现略有差异。

5. 在代码中使用模块

// main.cpp
import core;
import shaders;
import utils;

int main() {
    Mesh m;
    VertexShader vs;
    FragmentShader fs;
    // ...
}

• import core; 自动引入 core.module 导出的所有接口。

6. 链接阶段

g++ -std=c++20 -fmodules-ts main.cpp core.ifc shaders.ifc utils.ifc -o render_app

提示：链接时要确保 .ifc 文件位于正确路径，或者使用 -I 指定包含目录。

7. 常见坑与解决方案

问题	说明	解决办法
头文件仍被编译	仍有 #include 的旧代码	将所有 #include 替换为 import，或使用 -fno-implicit-modules 防止隐式模块
模块间循环依赖	模块 A 导入 B，B 又导入 A	通过拆分公共接口、使用前向声明或将公共部分放入第三模块解决
编译器兼容性	不是所有编译器都支持 C++20 Modules	选择支持的编译器（GCC 12+, Clang 14+, MSVC 19.29+）或使用第三方工具 module-interfaces 生成兼容代码
生成 .ifc 文件路径混乱	.ifc 生成在编译目录，链接时找不到	使用统一的输出目录 -fmodule-map-file 或手动指定路径

8. 与传统头文件的混用

在大型项目中，可能还需要保持与旧代码的兼容。可以把旧头文件包装为模块，例如：

// legacy.module
export module legacy;
export * from "old_header.hpp";

随后通过 import legacy; 使用旧接口，而不必改动旧代码。

9. 性能评估

在实际的渲染引擎中，使用 Modules 使得编译时间从 120 秒下降到 30 秒左右，整体构建速度提升 75%。这在持续集成（CI）环境中尤其重要，能够缩短代码提交到部署的周期。

10. 结语

C++20 Modules 为大规模 C++ 项目提供了更高效、更安全、更易维护的构建方式。虽然初期配置略显繁琐，但长远来看，模块化带来的编译速度提升和代码质量改进是值得的。随着编译器的成熟和工具链的完善，Modules 将成为 C++ 项目结构化的主流做法。

---

在 C++20 标准中，协程（Coroutines）被正式引入，极大地简化了异步编程与生成器的实现。本文从协程的基本原理出发，结合 std::future、std::async 与自定义的任务队列，演示如何在 C++ 中构建一个高效的异步任务执行框架。代码示例基于标准库，兼容主流编译器（g++ 10+、Clang 12+、MSVC 16.7+）。

---

1. 协程的核心概念

C++ 协程的实现围绕三个关键概念：

1. co_await：挂起协程，等待异步操作完成。
2. co_yield：生成器式协程，用于产生一系列值。
3. co_return：终止协程并返回结果。

协程的返回类型不再是传统意义上的 void 或 int，而是需要一个 promise 对象来保存协程状态。常见的返回类型为 `std::future

` 或自定义 `generator`。 — ## 2. 自定义 Promise 与 Awaiter 下面给出一个最简易的协程 Promise 和 Awaiter 的实现，演示 `co_await` 何时挂起与恢复。 “`cpp #include #include #include template struct awaitable { T value_; bool ready_ = false; awaitable(T value) : value_(value) {} bool await_ready() noexcept { return ready_; } void await_suspend(std::coroutine_handle h) { std::cout struct simple_promise { T value_; std::exception_ptr eptr_; simple_promise() : value_{} {} auto get_return_object() { return std::future (std::coroutine_handle::from_promise(*this)); } std::suspend_never initial_suspend() noexcept { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void return_value(T value) { value_ = value; } void unhandled_exception() { eptr_ = std::current_exception(); } }; template using simple_future = std::future ; template simple_future async_add(int a, int b) { co_return a + b; } “` 此代码演示了一个非常基础的协程返回 `std::future `，并在内部使用 `co_return` 返回计算结果。 — ## 3. 协程与异步任务队列 在实际项目中，往往需要将多个协程任务调度到线程池中执行。下面的实现演示了如何构建一个 **异步任务队列**，支持： – 提交协程任务（返回 `std::future`）。 – 支持任务优先级。 – 支持取消任务。 ### 3.1 任务包装结构 “`cpp #include #include #include #include #include #include #include #include struct Task { std::function func; int priority = 0; std::atomic cancelled{false}; Task(std::function f, int p = 0) : func(std::move(f)), priority(p) {} }; struct TaskCompare { bool operator()(const Task* a, const Task* b) const { return a->priority priority; // 大优先级排前面 } }; “` ### 3.2 线程池实现 “`cpp class ThreadPool { public: ThreadPool(size_t threads = std::thread::hardware_concurrency()) : stop_(false) { for (size_t i = 0; i lock(mtx_); stop_ = true; } cv_.notify_all(); for (auto& t : workers_) t.join(); } template auto submit(F&& f, Args&&… args) { using ReturnType = std::invoke_result_t; auto task_ptr = std::make_shared>( std::bind(std::forward (f), std::forward(args)…)); auto fut = task_ptr->get_future(); { std::unique_lock lock(mtx_); queue_.push(new Task([task_ptr](){ (*task_ptr)(); }, 0)); } cv_.notify_one(); return fut; } private: void worker_loop() { while (true) { Task* task = nullptr; { std::unique_lock lock(mtx_); cv_.wait(lock, [this] { return stop_ || !queue_.empty(); }); if (stop_ && queue_.empty()) return; task = queue_.top(); queue_.pop(); } if (!task->cancelled.load()) task->func(); delete task; } } std::priority_queue, TaskCompare> queue_; std::vector workers_; std::mutex mtx_; std::condition_variable cv_; bool stop_; }; “` ### 3.3 通过协程提交任务 “`cpp // 定义一个协程返回值类型 template using coro_future = std::future ; template coro_future async_task(ThreadPool& pool, std::function func) { // 将普通函数包装为协程 struct task_promise { std::function func_; std::promise prom_; auto get_return_object() noexcept { return coro_future (prom_.get_future()); } std::suspend_never initial_suspend() noexcept { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void return_value(T value) { prom_.set_value(value); } void unhandled_exception() { prom_.set_exception(std::current_exception()); } }; auto coro = [=](task_promise&& p) -> std::future { T result = p.func_(); co_return result; }(task_promise{std::move(func)}); // 把协程包装成任务提交到线程池 pool.submit([coro = std::move(coro)]() mutable { coro.wait(); // 等待协程完成 }); return coro.get_future(); } “` ### 3.4 示例：异步计算平方 “`cpp int main() { ThreadPool pool(4); auto fut = async_task (pool, []() { std::this_thread::sleep_for(std::chrono::seconds(1)); return 42 * 42; }); std::cout