standrad c++

在现代 C++ 开发中，手动管理内存已不再是唯一的选择，智能指针提供了更安全、更易维护的方案。本文将从两大核心智能指针——std::unique_ptr 与 std::shared_ptr——的语义、使用场景、以及与自定义资源释放机制的配合，逐步展开讨论。

---

1. std::unique_ptr：唯一所有权

1.1 基本语义

`std::unique_ptr

` 持有一个指向对象 `T` 的唯一所有权。它不允许拷贝，但支持移动。对象在 `unique_ptr` 生命周期结束时自动销毁。 “`cpp std::unique_ptr p1(new Foo); std::unique_ptr p2 = std::move(p1); // p1 变为空 “` ### 1.2 自定义删除器 默认使用 `delete` 释放对象，但可以传入自定义函数对象： “`cpp struct MyDeleter { void operator()(int* ptr) const { std::free(ptr); } }; std::unique_ptr p(new int[10], MyDeleter{}); “` ### 1.3 与 `std::make_unique` C++14 起提供 `std::make_unique`，可避免 `new`，提升异常安全： “`cpp auto p = std::make_unique (arg1, arg2); “` — ## 2. `std::shared_ptr`：共享所有权 ### 2.1 计数机制 `shared_ptr` 通过引用计数管理共享所有权。每个实例都有一个控制块，记录强引用计数（`shared_count`）和弱引用计数（`weak_count`）。 “`cpp std::shared_ptr sp1 = std::make_shared(); std::shared_ptr sp2 = sp1; // 计数 +1 “` ### 2.2 循环引用与 `std::weak_ptr` 若两个对象互相持有 `shared_ptr`，会导致引用计数永不归零，导致内存泄漏。`weak_ptr` 解决此问题： “`cpp class B; // 前向声明 class A { public: std::shared_ptr child; }; class B { public: std::weak_ptr parent; // 只弱引用 }; “` ### 2.3 `enable_shared_from_this` 当对象内部需要产生 `shared_ptr` 指向自身时，继承 `std::enable_shared_from_this`： “`cpp class Node : public std::enable_shared_from_this { public: std::shared_ptr self() { return shared_from_this(); } }; “` — ## 3. 与非 C++ 资源的绑定 ### 3.1 文件句柄 使用自定义删除器将文件指针封装为智能指针： “`cpp struct FileCloser { void operator()(FILE* fp) const { if (fp) fclose(fp); } }; std::unique_ptr file_ptr(fopen(“log.txt”, “r”), FileCloser{}); “` ### 3.2 网络套接字 同样适用于套接字关闭： “`cpp struct SocketCloser { void operator()(SOCKET sock) const { closesocket(sock); } }; std::unique_ptr sock_ptr(create_socket(), SocketCloser{}); “` — ## 4. 性能与最佳实践 | 场景 | 选用智能指针 | |——|————–| | 单一所有者 | `unique_ptr` | | 多重共享 | `shared_ptr`（小心循环引用） | | 需要自定义删除 | `unique_ptr` + 自定义删除器 | | 需要从 `this` 获取 `shared_ptr` | `enable_shared_from_this` | | 需要与非 C++ 资源绑定 | 任何智能指针 + 自定义删除器 | ### 4.1 避免不必要的 `shared_ptr` `shared_ptr` 的计数器和控制块开销不可忽视，尽量使用 `unique_ptr` 或裸指针（在生命周期可控时）。 ### 4.2 线程安全 `shared_ptr` 的引用计数是线程安全的，但对对象本身的修改不保证安全。若需在多线程中共享对象，请结合 `std::mutex` 或 `std::atomic`。 — ## 5. 小结 智能指针是 C++ 内存管理的核心工具，合理使用可以显著降低内存泄漏与悬挂指针的风险。`unique_ptr` 适合大多数单一所有权场景，`shared_ptr` 则在需要共享所有权且避免循环引用的情况下使用。结合自定义删除器，可将各种系统资源无缝整合进 RAII 模式，实现更安全、更简洁的代码。祝你在 C++ 之路上越走越稳！

在多线程程序中，常见的同步问题之一是共享资源的安全访问。传统做法往往是显式地使用 std::mutex 并在访问完成后手动解锁，容易出现忘记解锁、死锁等错误。C++ 的 RAII（Resource Acquisition Is Initialization）模式可以帮助我们以更安全、简洁的方式管理共享资源。下面演示一种基于 RAII 的多线程共享资源管理方案，并给出完整可编译的示例代码。

---

1. 设计思路

1. 封装互斥量：创建一个 MutexGuard 类，在构造函数中锁定 std::mutex，在析构函数中解锁。这样只要对象生命周期结束，锁就会自动释放，避免手动解锁的遗漏。
2. 共享资源包装：将共享数据放在一个 ThreadSafeContainer 类中，该类内部持有 MutexGuard 并提供对数据的访问接口。所有对共享资源的访问都必须通过该类的接口完成，保证了线程安全。
3. 避免死锁：在同一个 ThreadSafeContainer 内部，只使用单一互斥量，且不在锁定状态下调用其他锁，天然避免了死锁。

2. 代码实现

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <chrono>
#include <random>

/**
 * RAII-style mutex guard
 */
class MutexGuard {
public:
    explicit MutexGuard(std::mutex& mtx) : mtx_(mtx) {
        mtx_.lock();
    }
    ~MutexGuard() {
        mtx_.unlock();
    }
private:
    std::mutex& mtx_;
};

/**
 * Thread-safe container for an integer vector
 */
template<typename T>
class ThreadSafeContainer {
public:
    ThreadSafeContainer() = default;

    // 禁止拷贝与移动
    ThreadSafeContainer(const ThreadSafeContainer&) = delete;
    ThreadSafeContainer& operator=(const ThreadSafeContainer&) = delete;

    // 插入元素
    void push_back(const T& value) {
        MutexGuard guard(mtx_);
        data_.push_back(value);
    }

    // 读取元素，返回拷贝
    T at(size_t index) const {
        MutexGuard guard(mtx_);
        if (index >= data_.size()) {
            throw std::out_of_range("Index out of range");
        }
        return data_[index];
    }

    // 获取容器大小
    size_t size() const {
        MutexGuard guard(mtx_);
        return data_.size();
    }

private:
    mutable std::mutex mtx_;
    std::vector <T> data_;
};

/**
 * 生产者线程：向容器中不断添加随机整数
 */
void producer(ThreadSafeContainer <int>& container, int thread_id) {
    std::mt19937 rng(std::random_device{}());
    std::uniform_int_distribution <int> dist(1, 100);
    for (int i = 0; i < 100; ++i) {
        int val = dist(rng);
        container.push_back(val);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    std::cout << "Producer " << thread_id << " finished.\n";
}

/**
 * 消费者线程：尝试读取容器中的元素
 */
void consumer(const ThreadSafeContainer <int>& container, int thread_id) {
    for (int i = 0; i < 50; ++i) {
        try {
            size_t sz = container.size();
            if (sz > 0) {
                int val = container.at(0);
                std::cout << "Consumer " << thread_id << " read value: " << val << "\n";
            }
        } catch (const std::exception& e) {
            std::cerr << "Consumer " << thread_id << " error: " << e.what() << "\n";
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }
    std::cout << "Consumer " << thread_id << " finished.\n";
}

int main() {
    ThreadSafeContainer <int> container;

    // 创建生产者和消费者线程
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;

    for (int i = 0; i < 3; ++i) {
        producers.emplace_back(producer, std::ref(container), i + 1);
    }
    for (int i = 0; i < 2; ++i) {
        consumers.emplace_back(consumer, std::cref(container), i + 1);
    }

    // 等待所有线程完成
    for (auto& t : producers) t.join();
    for (auto& t : consumers) t.join();

    std::cout << "Final container size: " << container.size() << "\n";
    return 0;
}

3. 关键点剖析

• MutexGuard：构造函数锁定互斥量，析构函数解锁，确保异常安全。因为 std::mutex 的 lock()/unlock() 是不可抛异常的，故不需要额外的错误处理。
• ThreadSafeContainer：所有对 data_ 的访问都在 MutexGuard 的保护下进行。mutable 关键字允许在 const 成员函数中修改互斥量。
• 异常安全：在 at() 中若越界会抛出 std::out_of_range，但锁已经在 MutexGuard 的析构中安全释放。
• 性能考虑：如果并发量极高，可以进一步使用 std::shared_mutex 让读操作共享锁，写操作独占锁。但此处为了演示简洁，使用的是普通互斥量。

4. 扩展思路

• 读写锁：对读多写少的场景使用 std::shared_mutex，实现 shared_lock 与 unique_lock 的组合。
• 事务化操作：在 ThreadSafeContainer 内实现批量插入、删除等操作，保证原子性。
• 与条件变量配合：当消费者需要等待生产者生产一定数量后再继续，可以加入 std::condition_variable。

---

总结
通过 RAII 对互斥量进行封装，C++ 中的多线程共享资源管理可以变得异常简单、安全。只需将访问逻辑包装进类中，所有线程即可安全共享数据，避免手动锁/解锁带来的错误。希望本文能帮助你在实际项目中快速实现线程安全的数据结构。

C++20标准首次正式引入协程（Coroutine）这一特性，它为编写非阻塞、异步代码提供了更直观、优雅的语法。与传统的回调函数或事件循环相比，协程在代码可读性、错误处理以及资源管理方面都有显著优势。本文将从协程的基本原理、实现细节以及实际使用场景三个维度进行系统阐述，并给出完整的代码示例。

1. 协程的基本概念

协程是一种轻量级的子程序，具有以下核心特点：

1. 挂起与恢复：协程可以在任意位置挂起（suspend），随后在同一执行上下文中恢复（resume），实现非线性执行流。
2. 共享栈：与线程相比，协程共用同一线程栈，降低了内存占用和上下文切换成本。
3. 状态保持：挂起点之前的本地变量会被保存，恢复后可继续使用。

在C++中，协程通过co_await、co_yield、co_return等关键字实现。编译器会把协程函数转换为一个状态机，内部生成一个promise对象来维护协程的生命周期。

2. 协程实现细节

2.1 Promise对象

每个协程都有一个对应的promise_type，它负责：

• 初始化协程执行上下文。
• 提供get_return_object()返回协程句柄（std::coroutine_handle<>()）。
• 处理挂起点与结束点的逻辑。
• 存储协程的返回值、异常信息等。

struct task {
    struct promise_type {
        task get_return_object() {
            return {std::coroutine_handle <promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::terminate(); }
        void return_void() {}
    };
    std::coroutine_handle <promise_type> h;
};

2.2 生成器（Generator）示例

使用co_yield实现生成器：

template<typename T>
struct generator {
    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 {std::coroutine_handle <promise_type>::from_promise(*this)};
        }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle <promise_type> h;
    T next() {
        h.resume();
        return h.promise().current_value;
    }
    bool done() { return !h || h.done(); }
};

2.3 调度器（Scheduler）

协程的挂起点需要由调度器决定何时恢复。典型实现可采用事件循环或线程池：

class scheduler {
public:
    void schedule(std::coroutine_handle<> h) {
        tasks.push_back(h);
    }
    void run() {
        while (!tasks.empty()) {
            auto h = tasks.front();
            tasks.pop_front();
            h.resume();
            if (!h.done()) tasks.push_back(h);
        }
    }
private:
    std::deque<std::coroutine_handle<>> tasks;
};

3. 实际应用场景

3.1 异步 I/O

协程可以让 I/O 代码保持同步的写法，极大简化异步编程。以网络请求为例：

generator<std::string> fetch_url(std::string url) {
    co_yield "Sending request";
    // 假设 awaitable_type 表示异步 I/O
    auto result = co_await async_http_get(url);
    co_yield "Received response";
    co_return result;
}

3.2 生产者-消费者模型

协程生成器可以作为生产者，消费者通过 while (!gen.done()) 逐个取值，天然实现了管道式流控制。

3.3 游戏循环

在游戏引擎中，协程用于实现角色行为脚本、动画、AI决策等，让每个对象都有自己的执行状态，减少手动状态机的复杂度。

4. 性能评估

与传统线程相比，协程在内存占用和切换成本上具有明显优势。一次协程挂起/恢复只需更新一个指针，且不需要完整的线程栈拷贝。然而，协程本身并不解决 I/O 的同步性问题，真正的性能提升取决于底层 I/O 机制（如 epoll、IOCP）和事件驱动模型。

5. 开发者指南

1. 避免递归挂起：过度递归的协程可能导致堆栈溢出。
2. 异常安全：确保 promise_type::unhandled_exception 处理异常，否则协程会直接终止进程。
3. 资源管理：协程对象本身不拥有资源，需自行管理文件句柄、网络连接等。

6. 结语

C++协程为现代 C++ 编程带来了更直观的异步表达方式。掌握其基本原理和使用模式后，开发者可以在保持代码可读性的同时，显著提升程序的并发性能和资源利用率。未来随着标准库进一步完善，协程将在更广泛的领域（如机器学习、分布式系统）中得到深入应用。

概念（Concepts）是 C++20 引入的一项重要特性，用来为模板参数指定约束，从而使得模板编写更安全、可读性更强，并且编译器能够在编译阶段提供更精确、友好的错误信息。下面从概念的基本语法、典型应用以及实践中需要注意的几个要点来详细说明。

1. 概念的基本语法

template<typename T>
concept Integral = std::is_integral_v <T>;          // 只要 T 是整数类型，满足该概念

template<Integral T>                               // 通过约束声明
T add(T a, T b) { return a + b; }                  // add 只接受整数类型

• concept 关键字：定义一个概念。
• typename T：约束参数。
• = ...：概念的约束表达式。可以是一个类型特性、布尔常量表达式或更复杂的逻辑组合。
• 使用：在模板参数列表中使用 概念名 来限制模板参数的类型。

2. 组合概念与逻辑运算符

概念可以使用逻辑运算符（&&、||、!）进行组合，形成更细粒度的约束。

template<typename T>
concept Arithmetic = std::is_arithmetic_v <T>;

template<typename T>
concept Addable = Arithmetic <T> && requires(T a, T b) { a + b; };

template<Addable T>
T add(T a, T b) { return a + b; }

• requires 关键字：在概念内部声明语义检查，确保类型支持某些运算或成员。
• 可读性：把复杂的约束拆分成多个小概念，再组合使用，代码易于维护。

3. 概念与函数模板重载

概念可以用来区分不同实现，替代传统的 SFINAE。

template<std::ranges::range R>
auto sum_range(R&& r) {
    return std::accumulate(std::begin(r), std::end(r), 0);
}

template<std::integral T>
T sum_range(T a, T b) {
    return a + b;
}

编译器会根据参数类型自动匹配最合适的重载，错误信息更明确。

4. 约束作用域与编译期错误诊断

当模板实例化时，如果不满足概念约束，编译器会给出具体的错误提示，而不是泛型错误。

// 错误调用
add(1.5, 2);   // 报错：double 不是 Integral

// 通过概念修复
template<Integral T>
T add(T a, T b) { ... }

这让调试模板代码变得不再“黑箱”，大大提高开发效率。

5. 概念与性能

概念仅在编译阶段生效，对运行时性能没有影响。它们只是对类型进行静态检查，最终生成的代码与未使用概念时相同。

6. 常用内置概念

C++20 标准库提供了许多概念，例如：

• std::integral：整数类型
• std::floating_point：浮点类型
• std::assignable_from<T, U>：U 可赋值给 T
• `std::equality_comparable `：支持 `==`、`!=`

利用这些内置概念可以快速编写符合标准的模板。

7. 实践建议

1. 先定义小概念：拆分成易于理解的单一职责概念，再通过逻辑组合构建复杂约束。
2. 使用 requires：在概念内部使用 requires 语句检查语义（如运算符支持），让约束更精确。
3. 与 SFINAE 并用：在旧代码库中可以先用 SFINAE，逐步迁移到概念。概念能让旧代码更易读、错误更易定位。
4. 写单元测试：验证概念约束是否覆盖了所有预期类型，避免遗漏。

8. 小结

C++20 的概念为模板编程提供了强大的类型约束机制，提升了代码可读性、可维护性，并显著改善了编译时错误诊断。通过合理地拆分概念、组合使用 requires 与逻辑运算符，可以在保持模板灵活性的同时，得到更安全、更清晰的代码。未来的 C++ 标准化工作将进一步扩展概念的功能，期待在更多场景中看到其应用。

在 C++11 以及 C++14 期间，constexpr 只允许极其简单的函数——如返回常量表达式或执行非常有限的计算。C++17 对 constexpr 进行了重大提升，使其能够在编译期执行更为复杂的算法，例如递归、循环、以及更复杂的控制流。本文将通过一个实例来展示如何利用 C++17 的 constexpr 计算斐波那契数列，进而在编译期生成常量数组，提升运行时性能并降低错误概率。

1. 传统做法与其局限

传统上，如果想在编译期得到斐波那契数列的前 N 项，往往需要写一个模板递归：

template<std::size_t N>
struct Fib {
    static constexpr std::size_t value = Fib<N-1>::value + Fib<N-2>::value;
};

template<>
struct Fib <0> { static constexpr std::size_t value = 0; };

template<>
struct Fib <1> { static constexpr std::size_t value = 1; };

然后在编译时使用 `Fib

::value`。虽然可以得到单个值，但若要得到整个数组，需要再手动包装或使用宏，代码显得繁琐且可读性差。 ## 2. C++17 `constexpr` 的新特性 C++17 对 `constexpr` 的支持包括： – **`constexpr` 函数可以包含循环**：可以使用 `for` 或 `while`。 – **`constexpr` 函数可以包含 `if-else` 和三元运算符**：控制流更灵活。 – **`constexpr` 函数可以返回非字面量类型**：如 `std::array`。 正因为这些特性，我们可以直接在编译期构造一个完整的斐波那契数组。 ## 3. 在编译期生成斐波那契数组 下面给出一个完整可编译的示例，演示如何在编译期生成斐波那契序列，并在运行时打印： “`cpp #include #include #include // 计算斐波那契数列的 constexpr 函数 constexpr std::array generate_fib() { std::array arr{}; arr[0] = 0; arr[1] = 1; for (std::size_t i = 2; i `，其余代码保持不变。 – 与模板递归相比，代码更直观、易于理解。 ## 4. 性能对比 – **编译期生成**：生成过程在编译阶段完成，运行时不产生任何计算负担。 – **运行时计算**：若在 `main` 中使用普通函数在运行时计算斐波那契数列，CPU 需要进行多次加法运算。 – **模板递归**：编译时生成单个值，但若需要数组则仍需手动包装，且递归深度大时会导致编译时间增长。 通过 `constexpr` 生成的编译期常量，在大多数场景下能显著提升启动性能，尤其是在需要大量常量表或配置表的嵌入式系统中更为重要。 ## 5. 进阶使用：编译期排序 除了数值序列，`constexpr` 也可用于实现编译期排序。例如，使用 `constexpr` 版本的 `std::sort` 可以在编译期对数组进行升序排列，减少运行时开销。示例代码： “`cpp constexpr void bubble_sort(std::array& arr) { for (std::size_t i = 0; i arr[j+1]) { int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } } } constexpr std::array sorted = []{ std::array tmp = {5, 3, 4, 1, 2}; bubble_sort(tmp); return tmp; }(); “` 该方法在编译期完成排序，运行时可直接使用已排好序的数组。 ## 6. 结语 C++17 的 `constexpr` 让编译期计算变得强大而易用。通过在编译期生成斐波那契数组，我们实现了既简洁又高效的代码。未来的标准（如 C++20、C++23）将进一步扩展 `constexpr` 的功能，支持更复杂的数据结构与算法，进一步缩小编译期与运行期之间的差距。对 C++ 开发者而言，学习并善用 `constexpr` 是提升代码质量与性能的重要手段。

折叠表达式（fold expressions）是C++17中引入的一项强大特性，极大地简化了模板元编程中的可变参数包（parameter pack）处理。通过在单一表达式中递归地展开参数包，开发者可以轻松实现诸如“所有参数满足某条件”或“对参数包中的每个元素执行同一操作”等常见模式，而无需手写递归函数或使用std::initializer_list技巧。本文将从语法入手，演示如何使用折叠表达式完成复杂的泛型操作，并给出实际编码示例，帮助读者快速掌握这项技术。

1. 折叠表达式基础

折叠表达式分为两大类：左折叠（left fold）和右折叠（right fold）。它们的基本形式如下：

// 左折叠
(... op args)        // 先对最左侧参数执行 op，再继续往右
// 右折叠
(args op ...)        // 先对最右侧参数执行 op，再往左

其中op可以是任何二元运算符，例如+、&&、|、<<等。若参数包为空，则需要提供一个折叠基值（init value）来指定展开结果。例如：

template<typename... Args>
auto sum(Args... args) {
    return (args + ...);          // 右折叠，默认基值 0
}

若想让左折叠有同样的效果，可以写成：

return (... + args);             // 左折叠

1.1 单参数包折叠

C++17还支持单参数包折叠（unary pack expansion）：

template<typename... Args>
auto logical_and(Args... args) {
    return (true && ... && args); // 右折叠
}

如果Args...为空，编译器会使用左侧的true作为基值。

2. 折叠表达式的常见用途

2.1 逻辑判断

检查所有参数是否满足某条件：

template<typename... Args>
bool all_positive(Args... args) {
    return (args > 0 && ...);    // 右折叠
}

如果任何一个参数不满足，则整个表达式为false。

2.2 计数

统计参数包中满足条件的元素数量：

template<typename... Args>
int count_positive(Args... args) {
    return (static_cast <int>(args > 0) + ...);
}

2.3 逗号运算

对参数包中的每个元素执行副作用，例如打印：

template<typename... Args>
void print_all(Args... args) {
    (std::cout << ... << args) << '\n';  // 右折叠，按顺序输出
}

2.4 构造复杂表达式

把参数包转化为函数调用链：

template<typename F, typename... Args>
auto compose(F f, Args... args) {
    return (f(args)...); // 依次调用 f 对每个 args
}

3. 实战案例：泛型加密/解密流水线

假设我们要实现一个加密管线，每一步都是可选的加密器，且每个加密器都实现了operator()。我们可以利用折叠表达式把多个加密器串联起来：

#include <string>
#include <utility>
#include <iostream>

struct Base64 {
    std::string operator()(const std::string& s) const {
        // 简化示例：仅返回原字符串
        return s;
    }
};

struct Gzip {
    std::string operator()(const std::string& s) const {
        return s;
    }
};

struct CaesarCipher {
    std::string operator()(const std::string& s) const {
        return s;
    }
};

template<typename... Filters>
class Pipeline {
public:
    explicit Pipeline(Filters... filters) : filters_(std::make_tuple(std::move(filters)...)) {}

    std::string process(const std::string& data) const {
        return std::apply([&](auto&&... fs) {
            return (fs(..., std::forward<const std::string&>(data)) ...);
        }, filters_);
    }

private:
    std::tuple<Filters...> filters_;
};

// 调用示例
int main() {
    Pipeline p{Base64{}, Gzip{}, CaesarCipher{}};
    std::string result = p.process("Hello, world!");
    std::cout << "Result: " << result << '\n';
}

在上例中，std::apply配合折叠表达式完成了对每个过滤器的调用链。若要在编译时检查所有过滤器是否支持operator()，可以利用SFINAE或概念（concepts）进一步约束。

4. 与 Concepts 结合使用

C++20引入的概念可以与折叠表达式配合，进一步提升模板代码的可读性和错误提示质量。例如：

template<typename T>
concept Invocable = requires(T f, std::string s) {
    { f(s) } -> std::convertible_to<std::string>;
};

template<Invocable... Fs>
class SimplePipeline {
    // ...
};

在使用折叠表达式时，确保所有参数包元素都满足Invocable概念，否则编译错误将指明具体不满足的类型。

5. 性能与编译器实现

折叠表达式是编译期展开的，因此在运行时没有额外开销。它的优势在于：

• 可读性：单行代码即可完成多参数操作。
• 错误检测：编译器能在展开过程中检测所有实例化。
• 避免递归模板：避免深度模板递归导致的编译时间与错误堆栈。

然而，过度使用折叠表达式也可能导致编译时间膨胀，尤其在参数包非常大或复杂时。合理的做法是把折叠表达式用于逻辑判断、计数、打印等通用场景，而对需要更高灵活性的逻辑，仍然可以手写递归模板或使用constexpr函数。

6. 小结

折叠表达式是C++17提升模板编程表达力的重要工具。它让可变参数包的展开与处理变得简洁、直观。与C++20的概念相结合，可进一步提升代码的安全性与可维护性。熟练掌握折叠表达式不仅能减少模板代码量，还能让你在泛型编程中获得更高的表达效率。希望本文能帮助你在实际项目中快速上手，并灵活运用折叠表达式完成高效的模板元编程。

在 C++ 现代化进程中，智能指针（如 std::shared_ptr、std::unique_ptr）已经成为管理资源的重要工具。若想在自己的项目中使用自定义智能指针，核心任务之一就是正确实现拷贝和移动语义。下面以一个简易的 RefCountPtr 为例，演示完整的实现思路和关键细节。

1. 设计目标

• 自动管理引用计数：多个 RefCountPtr 对同一对象时，共享同一计数。
• 支持拷贝构造/赋值：拷贝后引用计数递增。
• 支持移动构造/赋值：移动后原对象置空，计数不变。
• 防止循环引用：通过弱引用 WeakRefCountPtr 解决。

2. 基础实现

#include <atomic>
#include <iostream>
#include <utility>

template<typename T>
class RefCountPtr {
public:
    explicit RefCountPtr(T* ptr = nullptr)
        : ptr_(ptr), count_(ptr ? new std::atomic <size_t>(1) : nullptr) {}

    // 拷贝构造
    RefCountPtr(const RefCountPtr& other) noexcept
        : ptr_(other.ptr_), count_(other.count_) {
        inc();
    }

    // 移动构造
    RefCountPtr(RefCountPtr&& other) noexcept
        : ptr_(other.ptr_), count_(other.count_) {
        other.ptr_ = nullptr;
        other.count_ = nullptr;
    }

    // 拷贝赋值
    RefCountPtr& operator=(const RefCountPtr& other) noexcept {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            count_ = other.count_;
            inc();
        }
        return *this;
    }

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

    ~RefCountPtr() {
        release();
    }

    T* operator->() const noexcept { return ptr_; }
    T& operator*() const noexcept { return *ptr_; }
    explicit operator bool() const noexcept { return ptr_; }
    size_t use_count() const noexcept { return count_ ? *count_ : 0; }

private:
    void inc() noexcept {
        if (count_) ++(*count_);
    }

    void release() noexcept {
        if (count_ && --(*count_) == 0) {
            delete ptr_;
            delete count_;
        }
    }

    T* ptr_;
    std::atomic <size_t>* count_;
};

关键点说明

• 原子计数：使用 `std::atomic ` 以保证多线程安全。
• release()：递减计数，若为零则销毁对象与计数器。
• 移动操作：移动后将源对象的指针和计数器置空，避免重复释放。

3. 弱引用实现

循环引用时，RefCountPtr 无法自行断开。通过弱引用来解决：

template<typename T>
class WeakRefCountPtr {
public:
    explicit WeakRefCountPtr(const RefCountPtr <T>& src)
        : ptr_(src.ptr_), count_(src.count_) {}

    WeakRefCountPtr(const WeakRefCountPtr& other)
        : ptr_(other.ptr_), count_(other.count_) {}

    WeakRefCountPtr& operator=(const WeakRefCountPtr& other) {
        ptr_ = other.ptr_;
        count_ = other.count_;
        return *this;
    }

    // 尝试升级为强引用
    RefCountPtr <T> lock() const {
        if (count_ && *count_ > 0) {
            return RefCountPtr <T>(ptr_, count_);
        }
        return RefCountPtr <T>(); // 空指针
    }

private:
    T* ptr_;
    std::atomic <size_t>* count_;
};

4. 测试案例

struct Node {
    int value;
    Node(int v) : value(v) { std::cout << "Node(" << value << ") constructed\n"; }
    ~Node() { std::cout << "Node(" << value << ") destroyed\n"; }
};

int main() {
    RefCountPtr <Node> p1(new Node(10));
    {
        RefCountPtr <Node> p2 = p1; // 拷贝
        std::cout << "use_count: " << p1.use_count() << "\n";
    } // p2 结束，计数减一
    std::cout << "use_count after block: " << p1.use_count() << "\n";

    RefCountPtr <Node> p3 = std::move(p1); // 移动
    std::cout << "p1 is " << (p1 ? "valid" : "null") << "\n";
    std::cout << "p3.use_count: " << p3.use_count() << "\n";
}

运行结果示例：

Node(10) constructed
use_count: 2
use_count after block: 1
p1 is null
p3.use_count: 1
Node(10) destroyed

5. 常见坑与优化

• 裸指针泄漏：在构造函数中一定要检查 ptr 是否为 nullptr。
• 多线程竞争：虽然使用 std::atomic，但仍需注意对 ptr_ 的读写是否存在数据竞争。
• 性能开销：每次拷贝都需要原子递增，若对象频繁拷贝可考虑使用 std::shared_ptr。
• 循环引用：如上所述，弱引用是常见的解决方案；在设计类图时尽量避免。

6. 结语

自定义智能指针可以更好地符合项目需求，但实现时必须细心处理拷贝、移动和计数等细节。上述 RefCountPtr 是一个完整、线程安全且可直接使用的参考实现，能够帮助你在 C++ 项目中快速搭建资源管理层。祝编码愉快！

在C++20中引入的 Concepts 机制，为泛型编程带来了前所未有的类型安全与可读性。本文将从概念的定义、实现方式以及在实际项目中的应用场景进行阐述，并给出一段完整的示例代码，帮助你快速掌握这一新特性。

一、概念的基本语义
Concepts 是一种对模板参数类型的限制声明。它让编译器能够在编译期检查参数是否满足预定的约束，从而避免了模板实例化后出现不易发现的错误。使用 Concepts 可以让错误信息更直观，提升代码的可维护性。

二、如何声明一个 Concept
Concept 的语法类似于模板声明，使用 concept 关键字：

template<typename T>
concept Arithmetic = requires(T a, T b) {
    { a + b } -> std::same_as <T>;
    { a - b } -> std::same_as <T>;
    { a * b } -> std::same_as <T>;
    { a / b } -> std::same_as <T>;
};

上述示例定义了一个名为 Arithmetic 的概念，它要求类型 T 支持四则运算并返回自身类型。

三、概念在函数模板中的使用
通过在模板参数前添加 requires 子句，可以让函数仅对满足特定概念的类型可见：

template<typename T>
requires Arithmetic <T>
T sum_of_vector(const std::vector <T>& vec) {
    T sum{};
    for (const auto& v : vec) sum += v;
    return sum;
}

若传入非算术类型，编译器会给出清晰的约束错误信息。

四、概念组合与命名空间
概念可以通过逻辑运算符（&&、||、!）组合，或使用 requires 关键字进一步约束：

template<typename T>
concept Number = std::is_arithmetic_v <T> && requires(T a, T b) {
    { a % b } -> std::same_as <int>;
};

组合概念可在不同模块间复用，降低耦合度。

五、实战案例：构建安全的矩阵乘法
假设我们有一个 Matrix 模板类，只支持在编译期确定行列数。我们可以使用 Concepts 约束矩阵类型满足乘法兼容性。

template<typename T, std::size_t R, std::size_t C>
class Matrix {
    std::array<std::array<T, C>, R> data_;
public:
    T& operator()(std::size_t i, std::size_t j) { return data_[i][j]; }
    const T& operator()(std::size_t i, std::size_t j) const { return data_[i][j]; }
};

template<typename T, std::size_t R, std::size_t C, std::size_t K>
concept MatMulCompatible = requires(const Matrix<T, R, C>& a, const Matrix<T, C, K>& b, Matrix<T, R, K>& c) {
    c = a * b; // 假设已重载 * 运算符
};

template<typename T, std::size_t R, std::size_t C, std::size_t K>
requires MatMulCompatible<T, R, C, K>
Matrix<T, R, K> operator*(const Matrix<T, R, C>& lhs, const Matrix<T, C, K>& rhs) {
    Matrix<T, R, K> result{};
    for (std::size_t i = 0; i < R; ++i)
        for (std::size_t j = 0; j < K; ++j)
            for (std::size_t k = 0; k < C; ++k)
                result(i, j) += lhs(i, k) * rhs(k, j);
    return result;
}

使用时：

Matrix<double, 2, 3> A{};
Matrix<double, 3, 4> B{};
auto C = A * B;  // 编译期检查行列是否匹配

六、常见坑与最佳实践

1. 错误信息可读性：若概念使用不当，错误信息可能仍然模糊。建议在 requires 子句中使用 static_assert 或自定义错误信息。
2. 模板参数默认值：概念不支持默认模板参数，使用时要注意。
3. 性能考虑：概念本身不产生运行时成本，但过度使用复杂约束可能导致编译时间增长。

七、结语
C++20 Concepts 为泛型编程注入了类型安全与可读性的双重提升。通过合理定义和组合概念，你可以在项目中大幅减少错误、提升代码可维护性。接下来可以尝试在你现有的泛型库中引入 Concepts，体验其带来的改进。祝编码愉快！

C++17 在标准库和语言层面做了许多重要更新，其中结构化绑定（structured bindings）是一个强大的特性，能够让我们用更简洁、直观的方式解构复杂的数据结构。本文将从语法、典型场景、性能影响以及潜在陷阱四个角度，对结构化绑定进行全面解读，并给出实用的编码示例。

---

1. 基本语法

auto [a, b, c] = some_tuple_or_pair;

• auto 必须与结构化绑定一起使用，编译器会根据右值的类型推导出每个成员的类型。
• [] 内列出的变量数目必须与右值中元素的数量匹配。
• 右值可以是：
  • std::tuple、std::pair
  • std::array
  • 自定义支持 std::get 或 operator[] 的类型
  • 带 begin()/end() 的范围（配合 auto&）

例子：解构 std::pair

std::pair<int, std::string> p{42, "Answer"};
auto [num, text] = p;   // num: int, text: std::string

例子：解构 std::tuple

std::tuple<int, double, char> t{1, 3.14, 'c'};
auto [i, d, ch] = t;   // i: int, d: double, ch: char

---

2. 典型使用场景

2.1 迭代容器时获取索引和值

std::vector <int> vec{10, 20, 30};

for (auto [idx, val] : vec | std::views::enumerate) {
    std::cout << idx << ": " << val << '\n';
}

注意：std::views::enumerate 需要 C++20；在 C++17 可以手动实现或使用 boost::irange.

2.2 解析返回值

std::optional<std::pair<int, std::string>> fetch();

if (auto [ok, result] = fetch(); ok) {
    std::cout << "Code: " << result.first << ", Msg: " << result.second << '\n';
}

这里 if 的初始化语句使用结构化绑定，条件表达式直接判断 ok。

2.3 替代多层解构的 auto&

auto& [x, y, z] = some_struct;   // 修改成员

---

3. 性能与实现细节

• 结构化绑定本质上会产生临时对象，编译器通常会使用 NRVO（返回值优化）或移动语义避免不必要的拷贝。
• 对 std::array、std::tuple 等 POD 结构，编译器可以直接将成员映射到局部变量，几乎没有额外开销。
• 当绑定的类型重载了 operator[] 时，访问是通过该运算符完成，可能会有额外的安全检查（例如 std::vector 的 bounds‑check in debug builds）。

---

4. 潜在陷阱与最佳实践

场景	问题	解决方案
使用 auto 推导不当	右值是 const 时，推导为 const T& 仍然会生成引用	如果想得到值，需要使用 auto [x, y] = std::move(rvalue); 或显式声明类型
与引用的混合	auto& [a, b] = pair; 只能在引用右值时使用	确保右值不是临时对象，否则会产生悬挂引用
解构范围	for (auto [idx, val] : vec | std::views::enumerate) 需要 C++20	在 C++17 可手写枚举器或使用第三方库
性能微差异	对非常大结构进行解构可能导致隐式复制	明确使用 auto& 或 auto&& 以避免不必要的拷贝
命名冲突	变量名与外部作用域相同	采用 using namespace std::literals; 时注意别名冲突，最好加前缀

---

5. 进一步阅读

1. C++官方标准 – §7.6.3.5 结构化绑定
2. 《C++17 标准实战》 – 第 12 章关于 tuple 与结构化绑定的深入讨论
3. 博客系列：Structuring Your Code with Structured Bindings（cppreference.com）

---

小结

结构化绑定让 C++ 开发者能够以更自然、更接近数据本身的方式访问复杂类型，显著提升代码可读性和维护性。熟练掌握其语法、适用范围及潜在坑，是每位现代 C++ 开发者必备的技能。祝编码愉快！

协程（coroutine）在C++20标准中正式引入，为传统的同步和异步编程带来了革命性的变化。相较于传统的线程和回调机制，协程以轻量级、可读性强、资源占用低的方式，实现了非阻塞的执行流。本文将从协程的基本概念入手，讲解如何使用C++20协程实现一个异步任务调度器，并进一步探讨其在并发编程中的优势与应用场景。

1. 协程基础

C++20中的协程是由 co_await、co_yield、co_return 这三个关键字实现的。协程函数的返回类型必须是可被 co_await 的对象，常见的如 std::future、std::generator 或自定义的 awaitable。

std::future <int> async_add(int a, int b) {
    co_return a + b;          // 直接返回结果
}

上面代码会在内部生成一个状态机，co_return 触发协程结束并把结果包装成 `std::future

`。 ## 2. 构建一个简单的任务调度器 ### 2.1 任务包装 首先我们需要一个通用的 `Task` 类型，包装任何可被 `co_await` 的协程。 “`cpp template class Task { public: struct promise_type { T value_; std::exception_ptr exception_; std::suspend_always initial_suspend() { return {}; } std::suspend_always final_suspend() noexcept { return {}; } Task get_return_object() { return Task{ std::coroutine_handle ::from_promise(*this) }; } void unhandled_exception() { exception_ = std::current_exception(); } void return_value(T val) { value_ = std::move(val); } }; using handle_type = std::coroutine_handle ; explicit Task(handle_type h) : handle_(h) {} Task(const Task&) = delete; Task(Task&& other) : handle_(other.handle_) { other.handle_ = nullptr; } ~Task() { if (handle_) handle_.destroy(); } T get() { if (handle_.promise().exception_) std::rethrow_exception(handle_.promise().exception_); return std::move(handle_.promise().value_); } private: handle_type handle_; }; “` ### 2.2 事件循环 为了在单线程中实现并发，需要一个事件循环。下面是一个最简版的事件循环，它会执行所有可就绪的任务。 “`cpp class EventLoop { public: void run() { while (!tasks_.empty()) { auto task = std::move(tasks_.front()); tasks_.pop_front(); task(); // 触发协程 } } void schedule(Task task) { tasks_.push_back(std::move(task)); } private: std::deque> tasks_; }; “` ### 2.3 例子：异步IO模拟 假设我们需要模拟一个异步IO操作，例如读取文件。我们用 `std::this_thread::sleep_for` 来表示等待。 “`cpp Task async_read(int bytes) { // 模拟异步等待 std::this_thread::sleep_for(std::chrono::milliseconds(100)); co_return bytes; // 读取成功，返回读取字节数 } “` ## 3. 协程与线程的比较 | 特点 | 线程 | 协程 | |——|——|——| | 开销 | 高（栈、上下文切换） | 低（仅存储状态） | | 可读性 | 代码顺序性差 | 代码顺序性好 | | 并发模型 | 多核共享 | 单核协作 | | 错误处理 | 传统异常/信号 | 统一异常捕获 | 协程通过在单线程中切换执行点，天然避免了锁竞争和死锁问题。但在多核并行加速场景下，仍需配合多线程或分布式方案。 ## 4. 实际应用场景 1. **网络服务器**：基于协程的网络框架（如 cpp-httplib、Boost.Asio 的协程模式）能让每个请求占用极小的栈空间，提升吞吐量。 2. **游戏引擎**：协程可以实现游戏逻辑的“顺序执行”，如动画、物理模拟，减少回调地狱。 3. **数据处理管道**：使用 `co_yield` 可以构建生成器式的数据流，实现按需消费、惰性计算。 ## 5. 小结 C++20协程为并发编程带来了全新的视角。通过协程与事件循环相结合，我们可以在单线程中实现高并发、低延迟的异步程序。虽然协程在多核并行方面并不直接提供加速，但它们可以作为更高级并发抽象的基础，帮助程序员写出更简洁、易维护的代码。 从现在起，尝试用协程重写你手中的回调网络代码，感受一下“暂停”和“恢复”给代码结构带来的改变吧。