stdcpp

在 C++20 中引入的模块（module）特性彻底改变了传统的预处理方式。利用模块，我们可以把每个插件实现成独立的模块，做到编译时的隔离、运行时的可插拔，并显著提升编译速度。以下演示如何构建一个简单的插件框架，并演示插件的动态加载与调用。

1. 设计思路

• 核心接口：定义一个纯虚基类 PluginInterface，所有插件都需要实现此接口。
• 模块化：每个插件实现为独立的模块文件（.cppm），只导出其实现。
• 动态加载：使用 dlopen/LoadLibrary 加载编译好的共享库，获取插件入口函数返回 PluginInterface*。

2. 代码示例

plugin_interface.h（核心模块）

#pragma once
#include <string>

export module plugin_interface;

export class PluginInterface {
public:
    virtual ~PluginInterface() = default;
    // 每个插件必须实现的业务方法
    virtual std::string name() const = 0;
    virtual std::string execute(const std::string& input) = 0;
};

// 插件入口点类型
using PluginCreateFunc = PluginInterface* (*)();

hello_plugin.cppm（插件模块）

#pragma once
export module hello_plugin;

#include "plugin_interface.h"

export class HelloPlugin : public PluginInterface {
public:
    std::string name() const override { return "HelloPlugin"; }
    std::string execute(const std::string& input) override {
        return "Hello, " + input + "!";
    }
};

export extern "C" PluginInterface* create_plugin() {
    return new HelloPlugin();
}

goodbye_plugin.cppm（另一插件）

#pragma once
export module goodbye_plugin;

#include "plugin_interface.h"

export class GoodbyePlugin : public PluginInterface {
public:
    std::string name() const override { return "GoodbyePlugin"; }
    std::string execute(const std::string& input) override {
        return "Goodbye, " + input + "!";
    }
};

export extern "C" PluginInterface* create_plugin() {
    return new GoodbyePlugin();
}

main.cpp（加载并使用插件）

#include "plugin_interface.h"
#include <filesystem>
#include <iostream>
#include <memory>
#include <vector>
#include <dlfcn.h>          // Linux；Windows请使用 <windows.h>

struct Plugin {
    void* handle;                 // 动态库句柄
    std::unique_ptr <PluginInterface> instance; // 插件实例
};

// 读取目录下所有 .so 文件并加载
std::vector <Plugin> load_plugins(const std::string& dir) {
    std::vector <Plugin> plugins;
    for (const auto& p : std::filesystem::directory_iterator(dir)) {
        if (p.path().extension() == ".so") {
            void* handle = dlopen(p.path().c_str(), RTLD_LAZY);
            if (!handle) {
                std::cerr << "dlopen failed: " << dlerror() << '\n';
                continue;
            }
            dlerror(); // 清除错误
            auto create = (PluginCreateFunc)dlsym(handle, "create_plugin");
            const char* dlsym_error = dlerror();
            if (dlsym_error) {
                std::cerr << "dlsym failed: " << dlsym_error << '\n';
                dlclose(handle);
                continue;
            }
            Plugin plugin{handle, std::unique_ptr <PluginInterface>(create())};
            plugins.push_back(std::move(plugin));
        }
    }
    return plugins;
}

int main() {
    auto plugins = load_plugins("./plugins");
    std::string user = "C++";
    for (auto& p : plugins) {
        std::cout << p.instance->name() << " => " << p.instance->execute(user) << '\n';
    }
    // 插件自动释放
    for (auto& p : plugins) dlclose(p.handle);
    return 0;
}

编译方式（Linux）

g++ -std=c++20 -fmodules-ts -c plugin_interface.h -o plugin_interface.o
g++ -std=c++20 -fmodules-ts -c hello_plugin.cppm -o hello_plugin.o
g++ -std=c++20 -fmodules-ts -c goodbye_plugin.cppm -o goodbye_plugin.o
g++ -std=c++20 -shared -o hello_plugin.so hello_plugin.o
g++ -std=c++20 -shared -o goodbye_plugin.so goodbye_plugin.o
g++ -std=c++20 -fmodules-ts main.cpp plugin_interface.o -ldl -o app

将生成的 hello_plugin.so 与 goodbye_plugin.so 放入 ./plugins 目录，运行 ./app 即可看到插件被动态加载并执行。

3. 优点与扩展

• 编译加速：模块只编译一次，消除头文件的重复预处理。
• 封装性强：插件内部实现完全独立，只暴露接口。
• 可插拔：在运行时添加/删除插件不需要重编译主程序。

可以进一步完善：

• 在插件中使用 std::optional 或 std::any 传递配置参数。
• 为插件提供生命周期管理（如 initialize/shutdown）。
• 用 std::filesystem 实现插件热加载、自动重启。

通过上述示例，你可以快速搭建一个 C++20 模块化的插件框架，为大型项目提供可维护、可扩展的插件化解决方案。

在 C++11 之前，管理动态分配的资源主要靠手写的 delete，这很容易导致内存泄漏、野指针等问题。C++11 开始引入了标准智能指针 std::unique_ptr、std::shared_ptr、std::weak_ptr，极大简化了资源管理。下面我们以 std::shared_ptr 为例，探讨自己实现一个共享指针时需要关注的核心设计与实现细节，帮助读者深入理解其工作机制。

---

1. 共享计数的基本思路

std::shared_ptr 的核心是引用计数。每个共享指针实例都持有一份对同一对象的引用计数，只有当计数降到 0 时才真正释放对象。实现共享计数通常采用一个独立的计数器对象（如 std::atomic<std::size_t>），或者直接将计数器放在一个控制块（control block）里。

template <typename T>
class SharedPtr {
private:
    T* ptr;                     // 实际指向的对象
    std::size_t* refCount;      // 引用计数
    // ...
};

关键在于 计数的原子性：多线程环境下，计数器的加减操作必须是线程安全的。常见做法是使用 std::atomic<std::size_t> 或者在每个 SharedPtr 的复制/移动操作时手动锁住计数器。

---

2. 构造与析构

2.1 默认构造

默认构造不指向任何对象，计数器为 nullptr。

SharedPtr() : ptr(nullptr), refCount(nullptr) {}

2.2 从裸指针构造

直接使用裸指针时，需要为计数器分配空间，并初始化为 1。

explicit SharedPtr(T* p) : ptr(p) {
    refCount = new std::size_t(1);
}

2.3 拷贝构造

拷贝构造时，需要把指针和计数器复制过来，并对计数器递增。

SharedPtr(const SharedPtr& other) : ptr(other.ptr), refCount(other.refCount) {
    if (refCount) ++(*refCount);
}

2.4 移动构造

移动构造时，将资源所有权转移给新对象，源对象置为空。

SharedPtr(SharedPtr&& other) noexcept : ptr(other.ptr), refCount(other.refCount) {
    other.ptr = nullptr;
    other.refCount = nullptr;
}

2.5 析构

析构时递减计数器，并在计数为 0 时删除指针和计数器。

~SharedPtr() {
    release();
}
void release() {
    if (refCount && --(*refCount) == 0) {
        delete ptr;
        delete refCount;
    }
}

---

3. 赋值操作

3.1 拷贝赋值

先递减自身计数，再复制别人的指针与计数器，最后递增新计数器。

SharedPtr& operator=(const SharedPtr& other) {
    if (this != &other) {
        release();            // 先释放旧资源
        ptr = other.ptr;
        refCount = other.refCount;
        if (refCount) ++(*refCount);
    }
    return *this;
}

3.2 移动赋值

先释放旧资源，然后转移指针和计数器。

SharedPtr& operator=(SharedPtr&& other) noexcept {
    if (this != &other) {
        release();
        ptr = other.ptr;
        refCount = other.refCount;
        other.ptr = nullptr;
        other.refCount = nullptr;
    }
    return *this;
}

---

4. 访问与操作

• operator* 与 operator->：提供对所管理对象的访问。
• use_count()：返回当前引用计数（如果计数器为空返回 0）。
• unique()：当计数为 1 时返回 true。

T& operator*() const { return *ptr; }
T* operator->() const { return ptr; }

std::size_t use_count() const { return refCount ? *refCount : 0; }
bool unique() const { return use_count() == 1; }

---

5. 线程安全细节

如果你想让 SharedPtr 在多线程中安全使用，最简单的做法是把 refCount 定义为 std::atomic<std::size_t>：

std::atomic<std::size_t>* refCount;

然后所有的加/减计数操作都使用 ++(*refCount) 与 --(*refCount)。
注意：--(*refCount) 的返回值不一定是新的计数，需要先递减后判断是否为 0。

---

6. 控制块（Control Block）改进

上面示例使用了两个独立的动态分配对象（ptr 与 refCount）。实际实现中，C++ 标准库通常采用一个 控制块（ControlBlock）来同时存储指针、计数、以及可选的自定义删除器。

struct ControlBlock {
    T* ptr;
    std::atomic<std::size_t> count;
    // 可选自定义删除器
    std::function<void(T*)> deleter;
};

SharedPtr 只持有指向 ControlBlock 的指针。这样可以在需要时支持 自定义删除器、弱引用（weak_ptr）等高级功能。

---

7. 完整代码（简化版）

#include <atomic>
#include <cstddef>
#include <functional>

template <typename T>
class SharedPtr {
private:
    struct ControlBlock {
        T* ptr;
        std::atomic<std::size_t> count;
        std::function<void(T*)> deleter;

        ControlBlock(T* p)
            : ptr(p), count(1), deleter([](T* p){ delete p; }) {}
    };

    ControlBlock* cb;

    void release() {
        if (cb && --cb->count == 0) {
            cb->deleter(cb->ptr);
            delete cb;
        }
    }

public:
    // 默认构造
    SharedPtr() : cb(nullptr) {}

    // 从裸指针构造
    explicit SharedPtr(T* p) : cb(new ControlBlock(p)) {}

    // 拷贝构造
    SharedPtr(const SharedPtr& other) : cb(other.cb) {
        if (cb) ++cb->count;
    }

    // 移动构造
    SharedPtr(SharedPtr&& other) noexcept : cb(other.cb) {
        other.cb = nullptr;
    }

    // 析构
    ~SharedPtr() { release(); }

    // 拷贝赋值
    SharedPtr& operator=(const SharedPtr& other) {
        if (this != &other) {
            release();
            cb = other.cb;
            if (cb) ++cb->count;
        }
        return *this;
    }

    // 移动赋值
    SharedPtr& operator=(SharedPtr&& other) noexcept {
        if (this != &other) {
            release();
            cb = other.cb;
            other.cb = nullptr;
        }
        return *this;
    }

    // 访问
    T& operator*() const { return *(cb->ptr); }
    T* operator->() const { return cb->ptr; }

    // 信息
    std::size_t use_count() const { return cb ? cb->count : 0; }
    bool unique() const { return use_count() == 1; }
};

---

8. 小结

• 引用计数是实现 shared_ptr 的核心，需保证线程安全。
• 控制块是实现自定义删除器、弱引用的关键结构。
• 拷贝/移动语义需仔细处理计数递增/递减和资源转移。
• 通过上述实现，可以更好地理解标准库 std::shared_ptr 的工作机制，为后续学习 std::weak_ptr、std::enable_shared_from_this 等高级特性打下坚实基础。

希望这篇文章能帮助你从底层实现角度把握共享指针的设计与实现，为日后的 C++ 代码写作提供更深的技术支撑。

在 C++20 标准中，概念（Concepts）被引入为一种新的语言特性，旨在为模板编程提供更直观、可读性更高且更安全的约束机制。与传统的 SFINAE 方式相比，概念让我们能够在函数模板、类模板以及别名模板等地方直接声明类型必须满足的语义要求，从而实现更好的错误诊断、代码可维护性以及编译速度提升。下面将从概念的基本语法、实际应用场景以及常见陷阱三方面展开说明。

---

1. 概念的基本语法与定义方式

// 定义一个概念：满足类型具有 operator<< 输出流
template<typename T>
concept Streamable = requires(T a, std::ostream& os) {
    os << a;                // 需要能被 << 运算符输出
};

• requires 表达式：用于描述在给定表达式上下文中必须满足的语义。
• 概念名（如 Streamable）可以直接在函数模板中使用。

2. 在模板函数中使用概念

// 传统方式（SFINAE）
template<typename T, std::enable_if_t<Streamable<T>, int> = 0>
void print(const T& val) {
    std::cout << val << std::endl;
}

// C++20概念方式
template<Streamable T>
void print(const T& val) {
    std::cout << val << std::endl;
}

• 简洁性：概念让函数签名更为干净，去掉了冗余的 enable_if 参数。
• 编译错误信息：若类型不满足 Streamable，编译器会直接提示该概念未被满足，错误定位更为准确。

3. 组合概念与默认参数

template<typename T>
concept EqualityComparable = requires(T a, T b) {
    { a == b } -> std::convertible_to <bool>;
};

template<EqualityComparable T, typename U = std::vector<T>>
T find_min(const U& container) {
    return *std::min_element(container.begin(), container.end());
}

• 默认类型参数：在模板参数中使用概念后，可以给其他模板参数提供默认类型，进一步提升代码复用性。

4. 对于类模板的约束

template<typename Container>
concept ContainerConcept = requires(Container c, typename Container::value_type v) {
    { c.begin() } -> std::input_iterator;
    { c.end() }   -> std::input_iterator;
    { *c.begin() } -> std::same_as<typename Container::value_type>;
};

template<ContainerConcept C>
void process(C& c) {
    for (auto& val : c) {
        // ...
    }
}

• 输入迭代器：通过 std::input_iterator 的概念约束，确保 begin() 和 end() 返回符合迭代器语义的对象。

5. 概念与标准库的配合

C++20 标准库已经开始利用概念，例如 std::ranges::input_range、std::ranges::viewable_range 等。我们在使用标准算法时可以直接利用这些概念：

#include <ranges>
#include <vector>

void foo(const std::vector <int>& v) {
    // 只接受输入范围
    std::ranges::sort(v | std::views::filter([](int x){ return x % 2 == 0; }));
}

6. 常见陷阱与注意事项

陷阱	说明	解决办法
概念未被满足时错误信息模糊	某些编译器（尤其是旧版）会给出不太直观的错误	使用最新编译器（gcc 11+, clang 13+, MSVC 19.29+），或结合 static_assert 进行自定义错误信息
过度约束导致可扩展性差	在概念中使用过多细节导致后期难以修改	设计概念时保持“最小约束”，将细节推迟到实现层
性能开销	requires 表达式在编译阶段会被求值	实际上编译器会进行优化，编译期计算不影响运行时性能；但若使用反射或模板元编程大规模求值，可能导致编译时间增长
与 SFINAE 混用	在同一个项目中既使用概念又使用 SFINAE 可能导致可读性下降	建议统一使用概念，或者在需要兼容旧编译器时保持 SFINAE 代码与概念代码分离

7. 小结

概念为 C++ 模板编程注入了新的活力：

• 可读性：模板签名清晰表达语义约束。
• 错误诊断：编译器直接给出概念未满足的提示。
• 性能：减少模板实例化的数量，提高编译速度。
• 可维护性：通过把约束拆解为细粒度概念，提升代码复用。

随着 C++20 的普及，越来越多的标准库组件采用概念来提升接口安全性和易用性。建议从项目中对常用模板函数、类模板逐步添加概念约束，从而获得更稳定、更易维护的代码库。

在 C++20 标准中，constexpr 与 consteval 两个关键字都与常量表达式（constant expression）相关，但它们在使用时有着本质的不同。本文将通过示例和实战场景来阐明二者的区别、适用范围以及如何在模板编程中合理使用它们。

---

1. constexpr 简介

constexpr 表明一个函数或变量在编译期即可求值，满足“常量表达式”条件后仍可在运行时使用。它允许：

• 编译期求值：若调用时满足所有参数为常量，编译器会在编译阶段计算结果。
• 运行时可用：即使不满足编译期条件，也能在运行时使用，只是此时会在运行时计算。

constexpr int square(int x) {
    return x * x;
}

int main() {
    constexpr int a = square(5);      // 编译期求值
    int b = square(10);               // 运行时求值
}

constexpr 适合用来实现可在编译期优化的数学函数、容器初始化等场景。

---

2. consteval 简介

consteval 是 C++20 新增的关键字，表示一定在编译期求值，否则编译错误。它是对 constexpr 的进一步限定，确保函数必须被调用为常量表达式。

consteval int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int val = factorial(5); // 编译期求值
    // int x = factorial(5);          // ❌ 编译错误：必须在编译期求值
}

由于编译期必然执行，consteval 的函数往往在实现细节上可以更严格，例如不允许返回引用、使用非 constexpr 变量等。

---

3. 二者的区别

关键字	是否必须在编译期求值	可在运行时使用	适用场景
constexpr	否	是	需要兼顾编译期优化与运行时灵活性
consteval	是	否	只想在编译期执行、保证安全的函数

3.1 编译期求值的限制

• constexpr 的函数可以返回非常量值、使用 if constexpr、递归等，只要在编译期满足所有条件即可。
• consteval 的函数必须满足所有编译期要求，编译器会在调用点直接展开，若出现不可编译期求值的代码会报错。

3.2 语义上的提示

• constexpr 表示“尽可能在编译期”，但并不强制；consteval 则是“绝对在编译期”。

---

4. 在模板编程中的应用

4.1 编译期生成数组

template<std::size_t N>
struct make_array {
    static constexpr std::array<int, N> value = []{
        std::array<int, N> arr{};
        for (std::size_t i = 0; i < N; ++i) arr[i] = static_cast<int>(i);
        return arr;
    }();
};

int main() {
    constexpr auto arr = make_array <10>::value; // 编译期初始化
}

此时使用 constexpr，因为我们希望数组可以在运行时也使用。

4.2 编译期计算元数值

consteval std::size_t fib(std::size_t n) {
    return n <= 1 ? n : fib(n-1) + fib(n-2);
}

template<std::size_t N>
struct fibonacci {
    static constexpr std::size_t value = fib(N);
};

int main() {
    static_assert(fibonacci <10>::value == 55);
}

fib 用 consteval，保证编译期递归展开；如果用 constexpr，static_assert 仍能通过，但如果有人把 fib 用于运行时调用，可能会产生不必要的运行时成本。

4.3 防止误用的 consteval

在一些库内部，你可能想确保某个算法只能在编译期使用，例如：

consteval int safe_divide(int a, int b) {
    if (b == 0) throw "division by zero";
    return a / b;
}

因为 consteval 强制编译期求值，任何错误都在编译阶段暴露，防止运行时错误。

---

5. 与 constinit 的关系

constinit 用于给全局/静态变量强制在编译期初始化，而不保证变量本身是常量。它经常与 constexpr 或 consteval 结合使用：

struct Config {
    static constexpr int max_threads = 8;
};

constinit int global_threads = Config::max_threads; // 必须在编译期初始化

在这个例子中，global_threads 必须在编译期初始化，若 max_threads 不是 constexpr，会报错。

---

6. 结语

• constexpr：灵活、兼容运行时，适合需要编译期优化但也可在运行时使用的场景。
• consteval：严格、强制编译期，适合保证安全性、消除运行时开销的函数。

在实际项目中，根据需求选择合适的关键字，既能得到编译期性能提升，又能保持代码的安全与可维护性。祝你在 C++20 的模板世界中玩得愉快！

在 C++17 之前，访问元组、数组或者自定义结构体的成员往往需要显式的访问函数或索引，例如 std::get<0>(t) 或者 obj.first。随着结构化绑定的加入，C++17 为我们提供了一种更加简洁、直观的方式来拆分这些复合类型。本文将系统阐述结构化绑定的语法、适用场景、性能影响以及常见陷阱，并通过一系列实战示例帮助你快速掌握这项技术。

1. 结构化绑定的基本语法

auto [a, b, c] = std::tuple<int, std::string, double>{1, "hello", 3.14};

这行代码等价于：

int a = std::get <0>(t);
std::string b = std::get <1>(t);
double c = std::get <2>(t);

关键点在于：

• 变量声明使用 auto（或显式类型）加方括号；
• 方括号内部列出绑定的名字；
• 右侧表达式必须是一个可解构的类型，例如 std::tuple, std::pair, std::array, 或者支持 std::get <I> 的自定义类型。

2. 支持结构化绑定的类型

类型	必须满足的条件	典型用法
std::tuple	`std::get
(t)` 成员函数	典型的多值返回
std::pair	first, second	键值对
std::array	operator[]	固定长度数组
自定义结构体	通过 std::tuple_size 与 `std::get
(obj)` 特化	对结构体成员做解构
std::array<T, N>	operator[]	也可使用 auto [x,y] 进行拆分
std::vector	需要 size() 和 operator[]	只能解构已知大小的子范围

注意：C++20 引入了 std::tuple_element_t<I, T> 以及更灵活的 auto [x, y] 绑定，对于可调用对象的返回值也支持解构。

3. 自定义类型的绑定实现

如果你有自己的结构体想使用结构化绑定，需要为其提供以下两类模板特化：

#include <tuple>

struct Person {
    std::string name;
    int age;
};

namespace std {
    template<> struct tuple_size<Person> : std::integral_constant<std::size_t, 2> {};
    template<> struct tuple_element<0, Person> { using type = std::string&; };
    template<> struct tuple_element<1, Person> { using type = int&; };

    template<std::size_t I> auto get(Person& p) -> decltype(auto) {
        if constexpr (I == 0) return p.name;
        else if constexpr (I == 1) return p.age;
    }
}

随后即可：

Person p{"Alice", 30};
auto [name, age] = p;   // name -> "Alice", age -> 30

4. 结构化绑定与范围 for

结构化绑定也能和范围 for 一起使用，让遍历集合中的元素更加直观：

std::map<int, std::string> mp = {{1, "one"}, {2, "two"}};

for (auto [key, value] : mp) {
    std::cout << key << " -> " << value << '\n';
}

与 C++17 之前的写法相比，省去了 auto it = mp.begin(); it != mp.end(); ++it 的繁琐。

5. 性能考虑

结构化绑定本质上等价于解包操作，它会：

• 对 std::tuple / std::pair：调用 std::get，通常是 constexpr、内联的访问；
• 对 std::array / C-style 数组：直接索引；
• 对自定义类型：取决于你提供的 get 实现。

大多数情况下，结构化绑定的开销与手写访问相当，甚至更少（因为消除了临时对象）。唯一需要注意的是 值语义：

auto [x, y] = std::make_pair(1, 2); // x, y are lvalue references

如果你想获取副本，应显式声明为 auto [x, y] = std::make_pair(1, 2); 并将类型改为 auto 的副本或使用 std::tuple_element_t。

6. 常见陷阱

1. 解构不完整
   若绑定的名字数量与类型的元素数量不一致，编译器报错。

   auto [a, b] = std::array<int, 3>{1, 2, 3}; // error

2. 不可绑定的临时
   临时对象的引用必须是 const，结构化绑定默认使用非 const 引用。

   auto [x, y] = std::pair(1, 2); // OK
   auto [x, y] = std::pair{1, 2}; // OK

3. 结构体成员是私有的
   需要提供 get <I> 或者将成员设为 public，否则编译失败。

4. 数组下标越界
   对 std::array 进行结构化绑定时，名字数量必须与 N 一致，否则会出现编译错误。

7. 实战案例

7.1 解析函数返回值

假设有一个查询数据库的函数返回 std::tuple：

std::tuple<int, std::string, double> queryUser(int id);

使用结构化绑定：

auto [uid, uname, balance] = queryUser(42);
std::cout << uid << ' ' << uname << ' ' << balance << '\n';

7.2 自定义 JSON 解析

struct JsonValue {
    std::string key;
    std::variant<std::string, int, double, bool> value;
};

std::tuple<JsonValue, JsonValue> parseTwo(JsonValue&& first, JsonValue&& second) {
    return { std::move(first), std::move(second) };
}

auto [first, second] = parseTwo(JsonValue{"age", 30}, JsonValue{"name", "Bob"});

7.3 与算法库结合

std::array<int, 3> arr = {3, 1, 2};
std::sort(arr.begin(), arr.end()); // arr becomes {1,2,3}
auto [a, b, c] = arr;
std::cout << a << ' ' << b << ' ' << c << '\n'; // 1 2 3

8. 小结

• 结构化绑定是 C++17 的一大亮点，为复合类型的解构提供了统一、简洁的语法；
• 只要满足 std::tuple_size、std::tuple_element 与 get <I> 的自定义类型，都能参与解构；
• 与传统访问方式相比，结构化绑定在可读性、可维护性上都有显著提升，且性能基本相同；
• 需注意引用、数组大小以及自定义类型的特化实现。

在你下一次写 C++ 代码时，试着把所有需要拆分的复合数据类型用结构化绑定代替显式访问，让代码更简洁、更易读。祝编码愉快！

协程（Coroutine）是 C++20 标准新增的一项特性，它为异步编程提供了更直观、可读性更强的语法。与传统的回调、Promise/Future 机制相比，协程可以让开发者像写同步代码一样书写异步逻辑，从而降低错误率并提升代码可维护性。本文将从协程的基本原理、关键关键字、实现细节以及典型应用场景进行阐述，并给出实战代码示例。

1. 协程基础

协程本质上是能够在执行过程中被“挂起”和“恢复”的函数。其实现依赖于两大概念：

• promise：协程体外的状态容器，负责管理协程的生命周期、返回值、异常等。
• handle：协程内部的控制入口，用于挂起、恢复、检查结束状态。

C++20 对协程的底层实现做了透明化，开发者只需使用 co_await、co_yield、co_return 等关键字即可。

2. 关键关键字

关键字	作用	典型用法
co_await	让协程等待一个 awaitable 对象完成	auto result = co_await asyncTask();
co_yield	产生一个值并挂起协程	co_yield value;
co_return	结束协程并返回值	co_return finalValue;
co_spawn	（需配合协程库）启动协程	auto handle = co_spawn(asyncFunc(), ...);

3. 典型实现：异步文件读取

以下示例演示如何使用协程实现异步文件读取，借助 C++20 标准库 std::future 以及自定义 awaitable。

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

struct async_file_reader {
    struct awaiter {
        std::ifstream& file;
        std::string& buffer;
        bool await_ready() { return !file.eof(); }
        void await_suspend(std::coroutine_handle<> h) {
            // 在后台线程读取文件
            std::async(std::launch::async, [&](){
                buffer.clear();
                if (file >> buffer) {
                    std::cout << "Read: " << buffer << "\n";
                }
                h.resume(); // 读取完毕恢复协程
            });
        }
        void await_resume() {}
    };
    awaiter operator co_await() { return {file, buffer}; }
    std::ifstream file;
    std::string buffer;
};

auto async_read_file(const std::string& path) -> std::future<std::string> {
    async_file_reader reader{std::ifstream(path), std::string{}};
    co_await reader;
    co_return reader.buffer;
}

int main() {
    auto fut = async_read_file("example.txt");
    std::cout << "Result: " << fut.get() << "\n";
}

4. 与线程池结合

协程可以轻松与线程池协同工作。下面展示一个简易的线程池与协程调度示例：

#include <thread>
#include <vector>
#include <queue>
#include <condition_variable>
#include <coroutine>

class thread_pool {
public:
    thread_pool(size_t n) : stop_(false) {
        workers_.reserve(n);
        for(size_t i = 0; i < n; ++i)
            workers_.emplace_back([this]{
                while(true){
                    std::function<void()> task;
                    {
                        std::unique_lock lock(m_);
                        cv_.wait(lock, [this]{ return stop_ || !tasks_.empty(); });
                        if(stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
    }
    ~thread_pool(){ stop(); }

    template<typename F>
    void enqueue(F&& f){
        {
            std::unique_lock lock(m_);
            tasks_.emplace(std::forward <F>(f));
        }
        cv_.notify_one();
    }
private:
    void stop(){
        {
            std::unique_lock lock(m_);
            stop_ = true;
        }
        cv_.notify_all();
        for(auto& w: workers_) w.join();
    }
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex m_;
    std::condition_variable cv_;
    bool stop_;
};

struct coroutine_task {
    struct promise_type;
    using handle_type = std::coroutine_handle <promise_type>;
    handle_type h;

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

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

void example_task(thread_pool& pool){
    coroutine_task ct([]() -> coroutine_task {
        std::cout << "Task started\n";
        co_await std::suspend_always{};
        std::cout << "Task resumed\n";
    }());
    pool.enqueue([ct = std::move(ct)](){ /* 线程池会执行此 lambda，进而调度协程 */ });
}

int main(){
    thread_pool pool(4);
    example_task(pool);
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

5. 性能与注意事项

• 栈使用：协程的状态保存在堆（promise）中，减少了栈空间占用，适合高并发场景。
• 异常传播：协程支持异常链，unhandled_exception 会将异常提升到外层。
• 生命周期管理：协程句柄若不及时销毁会导致内存泄漏，建议使用 RAII 包装。

6. 典型应用场景

1. 高性能网络服务器：使用协程 + IOCP / epoll，单线程即可处理数千连接。
2. 数据流处理：co_yield 可以实现可组合的数据流，类似 Rx 的 observable。
3. 游戏引擎：协程用于实现非阻塞任务调度、状态机、动画系统。
4. 异步数据库访问：将查询过程拆分为协程，避免线程阻塞。

7. 结语

C++20 协程为异步编程提供了更简洁、更直观的语法。掌握其基本原理、关键字以及与线程池、事件循环等传统技术的融合方式，可以帮助开发者构建高并发、低延迟的应用。随着标准化进程的深入，协程将成为 C++ 生态中不可或缺的一部分。

在多线程环境下，单例模式需要确保只有一个实例存在，并且在任何时刻都可以安全地访问该实例。下面给出几种常见的实现方式，并对其优缺点进行简要说明。

1. 局部静态变量（Meyers单例）

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;   // C++11之后的编译器保证线程安全
        return instance;
    }

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

private:
    Singleton() = default;
};

• 优点：实现简洁，编译器保证线程安全；延迟初始化（第一次调用时创建）。
• 缺点：无法控制实例的销毁时机（在程序退出时由系统负责）。

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

class Singleton {
public:
    static Singleton* instance() {
        Singleton* tmp = instance_;
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            tmp = instance_;
            if (!tmp) {
                tmp = new Singleton;
                instance_ = tmp;
            }
        }
        return tmp;
    }

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

private:
    Singleton() = default;
    static std::atomic<Singleton*> instance_;
    static std::mutex mutex_;
};

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

• 优点：只有在首次创建实例时才加锁，后续访问更快。
• 缺点：实现复杂，易出错；需要 C++11 原子和内存序保证。

3. 静态成员指针 + 互斥量 + std::call_once

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

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

private:
    Singleton() = default;
    static Singleton* instance_;
    static std::once_flag flag_;
};

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

• 优点：代码更安全，避免了手动锁；兼容 C++11 及以后。
• 缺点：需要手动管理实例的销毁，通常可通过 atexit 或者 std::unique_ptr 自动释放。

4. 使用 std::shared_ptr 与 std::weak_ptr

如果单例需要按需销毁，可以使用 std::shared_ptr 与 std::weak_ptr 组合：

class Singleton {
public:
    static std::shared_ptr <Singleton> instance() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (auto sp = ptr_.lock()) {
            return sp;
        }
        auto sp = std::shared_ptr <Singleton>(new Singleton);
        ptr_ = sp;
        return sp;
    }

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

private:
    Singleton() = default;
    static std::weak_ptr <Singleton> ptr_;
    static std::mutex mutex_;
};

std::weak_ptr <Singleton> Singleton::ptr_;
std::mutex Singleton::mutex_;

• 优点：实例可被销毁后再次创建，资源更灵活。
• 缺点：实现更复杂，性能略低。

小结

• 对于大多数 C++11 及以后项目，Meyers单例（局部静态变量）已足够，代码简洁且线程安全。
• 若需要更细粒度的控制或想延迟销毁，推荐使用 std::call_once 或 std::shared_ptr 方案。
• 双重检查锁虽然理论上更快，但在 C++11 的内存模型下实现复杂且不推荐使用。

选择合适的实现方式，既能保证线程安全，又能满足项目的资源管理需求。

在 C++20 之前，对容器的查询通常需要编写一系列标准算法，代码往往显得冗长且难以阅读。C++20 通过引入 std::ranges 与管道操作符（|）彻底改变了这一点。本文将演示如何利用 std::ranges 在单行代码中完成复杂的数据筛选、变换和排序，极大提升代码可读性与可维护性。

---

1. std::ranges 的基本概念

关键词	含义	示例
视图（View）	逻辑上对序列进行“投影”，不复制数据	std::views::filter、std::views::transform
管道操作符	把视图链连接成一条链	data | std::views::filter(...) | std::views::transform(...)
谓词/转换函数	传给视图的自定义函数	[](int x){ return x%2==0; }

提示：视图是延迟求值的，直到你实际遍历它们为止。

---

2. 经典示例：从一组整数中筛选偶数、取平方并排序

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>

int main() {
    std::vector <int> numbers{1, 4, 3, 6, 8, 7, 2};

    auto processed = numbers
        | std::views::filter([](int n){ return n % 2 == 0; })          // 只保留偶数
        | std::views::transform([](int n){ return n * n; })           // 取平方
        | std::views::common();                                       // 转为可随机访问

    std::vector <int> sorted(processed.begin(), processed.end());
    std::ranges::sort(sorted);

    std::cout << "Result: ";
    for (int n : sorted)
        std::cout << n << ' ';
    std::cout << '\n';
}

输出：

Result: 4 16 36 64 

说明

• std::views::common() 用于将视图转换为支持随机访问的容器（std::vector）。
• std::ranges::sort 只适用于随机访问容器；若你不需要排序，直接遍历视图即可。

---

3. 高级用法：结合多种视图与自定义谓词

假设我们要处理一个 std::vector<std::string>，需求是：

1. 只保留长度大于 5 的字符串
2. 转为大写
3. 按字典序倒序排列

#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <algorithm>
#include <cctype>

int main() {
    std::vector<std::string> words{"algorithm", "range", "view", "pipeline", "lambda", "function"};

    auto uppercase = [](std::string s) {
        std::transform(s.begin(), s.end(), s.begin(), ::toupper);
        return s;
    };

    auto processed = words
        | std::views::filter([](const std::string& s){ return s.size() > 5; })
        | std::views::transform(uppercase)
        | std::views::common();

    std::vector<std::string> sorted(processed.begin(), processed.end());
    std::ranges::sort(sorted, std::greater<>{});

    for (const auto& s : sorted)
        std::cout << s << ' ';
}

输出：

ALGORITHM FUNCTION 

---

4. 性能考量

• 延迟执行：视图在迭代时才真正执行，避免了中间容器的复制。
• 内存占用：只保留需要的元素，节省空间。
• 可组合性：可以链式叠加视图，保持单一职责。

注意：若视图链包含 过滤 与 变换，在每个元素上都会执行两次操作（一次过滤一次变换）。如果变换开销较大，可考虑先变换再过滤。

---

5. 与传统算法对比

需求	C++14 示例	C++20 std::ranges 示例
取偶数并平方	std::copy_if + std::transform	views::filter + views::transform
复杂筛选	多个 std::copy_if	单行链式调用
可读性	代码行数多	代码简洁、直观

---

6. 结语

C++20 的 std::ranges 为我们提供了一套强大而优雅的数据处理工具，让传统算法变得更具表现力。熟练运用视图和管道操作符后，复杂的数据处理逻辑都可以被压缩成一行代码，既提升了可读性，也减少了潜在的错误。

在后续的项目中，建议你：

1. 先从简单的 filter 与 transform 开始尝试。
2. 熟悉 common()、indirectly_readable 等概念，确保视图的类型兼容。
3. 在性能敏感的地方，结合 std::views::take, std::views::drop, std::views::split 等高级视图进一步优化。

祝你编码愉快，玩转 C++20！

C++20 引入了概念（Concepts），这是一种强类型约束机制，能够让模板编程更安全、可读性更高、错误信息更友好。本文从概念的基本定义、语法结构开始，逐步讲解如何在实际项目中使用概念来替代传统的 enable_if，并展示几个常见的自定义概念及其在标准库中的应用。先从最小可运行的例子开始，接着深入解释概念如何与模板参数一起工作，最后给出一个完整的示例：实现一个通用的排序函数，该函数仅接受支持 < 操作符的类型。文章末尾提供了常见错误排查技巧和未来扩展建议，帮助你在项目中顺利迁移到基于概念的代码结构。

在 C++20 中，concepts 与 requires 关键字是用于模板约束的两种主要工具，它们虽然目的相同——在编译时对模板参数进行检查，但在语法结构、可读性以及使用场景上有显著差异。本文将对二者进行对比，并给出实际编码示例，帮助你更好地把握何时使用哪一种。

1. 语法概览

关键字	语法位置	作用域	典型用法
concept	先声明再使用	在整个模板中	定义可复用的约束
requires	直接放在函数/类/模板参数列表中	在定义局部	直接嵌入约束表达式

示例 1：使用 concept

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

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

示例 2：使用 requires

template<typename T>
requires requires(T a) {
    { ++a } -> std::same_as<T&>;
}
T add_one(T x) { return ++x; }

两者功能相同，但约束表达式被直接写在 requires 关键字后面，省去了单独定义 concept 的步骤。

2. 何时使用 concept

1. 可重用约束：当同一组约束需要在多处使用时，定义 concept 可以避免重复书写，提高可读性和维护性。
2. 文档化：concept 名称能直观地表达约束意图（如 Incrementable、Sortable 等），有助于代码阅读。
3. 复杂约束：当约束组合复杂时，将其封装为 concept 能降低模板定义的视觉噪音。

template<Incrementable T, Incrementable U>
auto sum(T a, U b) { return a + b; }

3. 何时使用 requires

1. 一次性约束：仅在当前模板中使用，且约束不需要复用时，直接使用 requires 更简洁。
2. 局部特殊化：在特化模板时，requires 能直接表达特化条件。
3. 避免命名冲突：若你不想在全局范围定义新名称，或者约束非常短小，使用 requires 更为直观。

template<typename T>
requires std::integral <T>
void print(T x) { std::cout << x << '\n'; }

4. 性能与编译器实现

从编译器实现角度，concept 和 requires 本质上都依赖模板元编译。编译器会在模板实例化时检查约束是否满足。大多数现代编译器（GCC 11+、Clang 13+、MSVC 19.33+）对两者实现均已成熟，性能差异可以忽略不计。

5. 兼容性与最佳实践

• 使用 concept 定义基础约束，然后在需要的地方通过 requires 引用它们，既能复用又能保持代码简洁。
• 对于复杂的逻辑，分解成小 concept 再组合使用，可显著提升代码可读性。
• 牢记 SFINAE 与 Concepts 的区别：Concepts 的错误信息更友好、编译速度更快，但并非所有旧编译器均支持。

6. 结语

C++20 的 Concepts 与 Requires 为模板编程带来了更强的类型安全与表达力。正确理解两者的语法和适用场景，能够让你的模板代码更加健壮、易读。建议在项目初期就引入 Concepts，逐步用它们替换传统的 SFINAE 方案，从而获得更好的开发体验。