standrad c++

在 C++17 之前，constexpr 函数的功能相对有限，主要只能返回常量表达式，且内部只能包含简单的算术运算、返回语句和限定的控制流。随着 C++17 的加入，constexpr 的能力得到了大幅提升，几乎可以与普通函数无差别地使用。这一变革使得我们能够在编译期完成更复杂的计算，极大地提升程序的性能与安全性。本文将从概念、实现细节以及实际应用三个角度，详细剖析 C++17 中 constexpr 的新特性。

---

1. 关键概念回顾

• constexpr 函数：在编译期求值的函数，其返回值和内部表达式必须是常量表达式。
• 常量表达式：在编译期可以被求值的表达式。
• constexpr 变量：使用 constexpr 修饰的变量，必须在声明时就初始化，且值在编译期已知。

2. C++17 引入的新特性

位置	新特性	说明
constexpr 函数体	支持更复杂的控制流	if, switch, for, while, do-while, try-catch 等均可使用
语义	可以返回非字面量类型	如自定义类、std::array、std::tuple 等
变量	可以在 constexpr 变量中使用 new	通过 constexpr 构造的对象可以包含动态分配的内存，但必须在编译期能解析
递归	允许递归调用	但递归深度仍受编译器限制，避免无限递归
访问	可以访问非 constexpr 成员	只要在编译期能确定其值

3. 典型使用场景

3.1 预先计算数组大小

constexpr std::size_t factorial(std::size_t n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr std::size_t N = factorial(5); // 120

int arr[N]; // 编译期确定大小

3.2 生成查找表

constexpr std::array<int, 256> make_lookup() {
    std::array<int, 256> arr{};
    for (int i = 0; i < 256; ++i)
        arr[i] = i * i; // 预计算平方
    return arr;
}

constexpr auto lookup = make_lookup();

3.3 编译期类型检查

template<typename T>
constexpr bool is_integral_v = std::is_integral_v <T>;

static_assert(is_integral_v <int>, "int should be integral");
static_assert(!is_integral_v <double>, "double should not be integral");

4. 注意事项与陷阱

1. 编译器支持：虽然 C++17 标准已定义，但并非所有编译器都完整实现。务必检查编译器版本与实现细节。
2. 递归深度：C++17 对递归求值没有显式限制，但编译器对递归深度有限制，过深会导致编译失败。
3. 异常处理：try-catch 在 constexpr 函数中可用，但异常必须在编译期可解析，且不允许抛出非 constexpr 类型。
4. 内存管理：new 可以在 constexpr 函数中使用，但编译器必须能够在编译期模拟内存分配，实际执行时仍在运行时完成。

5. 对性能的影响

通过 constexpr 的编译期求值，可以消除运行时的计算开销，尤其在数值密集型算法、嵌套循环、字符串处理等场景中表现尤为明显。例如，预先生成的查找表可以将原本 O(n) 的运算降为 O(1)。此外，编译期计算有助于避免在运行时产生临时对象，减少内存分配与拷贝。

6. 结语

C++17 对 constexpr 的扩展，使得在编译期完成更为复杂的计算成为可能。程序员可以将更多业务逻辑提前到编译阶段，既提升了执行效率，又让代码更具安全性。未来的标准（如 C++20）将进一步强化 constexpr，引入更强大的模板元编程与即时编译特性，让我们拭目以待。

在 C++23 标准中，协程（Coroutines）作为一种语言层面的异步编程原语，已经成熟到可以直接用于生产代码。本文从协程的基本概念、实现原理，到如何在实际项目中用它来实现异步 I/O、生成器、并发管道等场景，给出完整的示例和实用技巧。

---

1. 协程的核心概念

术语	含义	关键字
协程函数	产生 awaitable 对象的函数	co_await, co_yield, co_return
awaiter	抽象异步操作	需要实现 await_ready(), await_suspend(), await_resume()
promise_type	协程对象的状态容器	通过 std::experimental::coroutine_handle 与 promise_type 交互

重要点：协程本身是同步执行的，直到遇到 co_await，此时才会挂起。挂起后，控制权返回给调用者，等到异步事件完成后再恢复。

---

2. 一个完整的异步 I/O 示例

下面演示如何使用 C++23 的协程与标准库的 std::experimental::net（假设已实现）实现一个简单的 HTTP GET 客户端。

#include <iostream>
#include <string>
#include <experimental/coroutine>
#include <experimental/net>

using namespace std::experimental;
namespace net = std::experimental::net;

// awaitable 代表一个异步操作
struct AsyncRead {
    net::tcp_stream stream;
    std::vector <char> buffer;
    std::experimental::coroutine_handle<> handle; // 协程句柄

    // 当异步读完成后恢复协程
    void operator()() {
        handle.resume();
    }

    // await_ready：是否同步完成
    bool await_ready() noexcept { return false; }

    // await_suspend：挂起协程，并启动异步读
    bool await_suspend(std::experimental::coroutine_handle<> h) noexcept {
        handle = h;
        stream.async_read_some(buffer.data(), buffer.size(), *this);
        return true; // 挂起
    }

    // await_resume：获取结果
    std::size_t await_resume() noexcept { return buffer.size(); }
};

async<std::vector<char>> fetch(const std::string& host, const std::string& path) {
    net::tcp_stream stream;
    stream.connect(host, "80"); // 同步 connect

    // 发送 HTTP 请求
    std::string req = "GET " + path + " HTTP/1.1\r\n"
                      "Host: " + host + "\r\n"
                      "Connection: close\r\n\r\n";
    stream.write(req.data(), req.size());

    // 等待响应
    AsyncRead reader{stream, std::vector <char>(8192)};
    co_await reader;

    // 读取完毕后返回缓冲区
    co_return std::move(reader.buffer);
}

int main() {
    auto task = fetch("example.com", "/");
    task.wait(); // 阻塞直到协程完成
    std::cout << "收到 " << task.result().size() << " 字节\n";
}

要点

• `async ` 是 C++23 标准中的 `std::experimental::coroutine_traits` 所生成的任务类型。
• await_ready、await_suspend、await_resume 三个函数构成 awaitable 的完整协议。
• handle.resume() 是恢复协程的关键调用。

---

3. 协程生成器（Generator）

协程可以用来实现惰性序列（Generator），大大简化迭代器实现。

#include <experimental/coroutine>
#include <iostream>

template<typename T>
struct Generator {
    struct promise_type {
        T current_value;
        std::experimental::suspend_always yield_value(T value) {
            current_value = value;
            return {};
        }
        std::experimental::suspend_always initial_suspend() { return {}; }
        std::experimental::suspend_always final_suspend() noexcept { return {}; }
        Generator get_return_object() {
            return Generator{std::experimental::coroutine_handle <promise_type>::from_promise(*this)};
        }
        void unhandled_exception() { std::terminate(); }
        void return_void() {}
    };

    using handle_t = std::experimental::coroutine_handle <promise_type>;
    handle_t coro;

    explicit Generator(handle_t h) : coro(h) {}
    ~Generator() { if (coro) coro.destroy(); }

    T next() {
        coro.resume();
        return coro.promise().current_value;
    }

    bool done() const { return !coro || coro.done(); }
};

Generator <int> fib() {
    int a = 0, b = 1;
    co_yield a;
    while (true) {
        co_yield b;
        int tmp = a + b;
        a = b;
        b = tmp;
    }
}

int main() {
    auto g = fib();
    for (int i = 0; i < 10; ++i)
        std::cout << g.next() << ' ';
}

优点

• 惰性：每次 next() 调用才计算下一个值。
• 状态封装：协程内部维护了迭代状态，无需手写迭代器类。

---

4. 并发管道（Pipeline）

协程可以串联多层处理逻辑，形成流水线（Pipeline），非常适合大规模并行数据处理。

#include <experimental/coroutine>
#include <queue>
#include <thread>
#include <atomic>

template<typename In, typename Out>
class Pipeline {
    std::queue <In> input;
    std::queue <Out> output;
    std::atomic <bool> done{false};

    struct awaitable {
        Pipeline& pipe;
        awaitable(Pipeline& p) : pipe(p) {}
        bool await_ready() noexcept { return !pipe.input.empty(); }
        bool await_suspend(std::experimental::coroutine_handle<> h) {
            std::thread([&]{
                // Simulate work
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
                pipe.input.pop();
                h.resume();
            }).detach();
            return true;
        }
        In await_resume() { return pipe.input.front(); }
    };

public:
    void push(In v) { input.push(v); }
    std::experimental::generator <Out> run() {
        while (!done || !input.empty()) {
            auto v = co_await awaitable{*this};
            // 处理
            output.push(v * 2);
            co_yield output.front();
            output.pop();
        }
    }
    void stop() { done = true; }
};

实际场景：日志收集、视频帧处理、网络流式传输等。

---

5. 常见陷阱与调试技巧

误区	解决方案
协程挂起后忘记恢复	通过 co_await 的 awaitable 实现 await_suspend 时务必调用 handle.resume()
资源泄漏	promise_type 的 final_suspend 里记得销毁协程句柄；使用 std::experimental::coroutine_handle::destroy()
性能不佳	大量协程频繁创建/销毁会导致堆碎片；可使用协程池或预分配内存
调试困难	由于协程内部状态隐藏，建议使用 -fsanitize=address + -fno-inline，或手动打印状态日志

---

6. 小结

• C++23 的协程提供了完整的异步编程模型，兼容传统同步代码，易于集成。
• 通过实现自定义 awaiter 和 promise_type，可与任何异步 I/O 或任务调度系统结合。
• 生成器、管道等模式可以让代码更简洁、可维护。

实践建议：先从简单的异步 I/O 开始，逐步扩展到协程生成器和并发管道；并关注协程池、内存管理等高级细节，才能真正发挥协程在高性能 C++ 应用中的优势。

移动语义（Move semantics）是 C++11 引入的核心特性之一，主要用于优化对象的复制与转移，提升性能，减少不必要的拷贝开销。下面从概念、实现细节、常见用法以及实际案例四个方面展开讨论。

一、移动语义概述

1. Rvalue 与 Lvalue
   • Lvalue：左值，具有持久地址，常在左侧出现，如变量。
   • Rvalue：右值，临时对象或表达式结果，没有持久地址，常在右侧出现。
2. std::move
   • 把 Lvalue 强制转换为 Rvalue，告诉编译器对象的资源可以被“转移”。
3. 移动构造函数 & 移动赋值运算符
   • 语义：把源对象的资源所有权转移到目标对象，源对象保持可用但状态未知。
   • 常见实现：T(T&& other) noexcept、T& operator=(T&& other) noexcept。

二、实现细节

• 资源转移

  class Buffer {
      char* data;
      size_t size;
  public:
      Buffer() : data(nullptr), size(0) {}
      Buffer(size_t n) : data(new char[n]), size(n) {}
      Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
          other.data = nullptr;
          other.size = 0;
      }
      Buffer& operator=(Buffer&& other) noexcept {
          if (this != &other) {
              delete[] data;
              data = other.data;
              size = other.size;
              other.data = nullptr;
              other.size = 0;
          }
          return *this;
      }
  };

• 防止自我移动

  • 在移动赋值运算符中，先检查 this != &other。

• noexcept

  • 移动构造函数与赋值运算符最好加 noexcept，因为 STL 容器依赖此属性决定使用移动还是复制。

三、常见应用场景

1. STL 容器
   • std::vector、std::string 在扩容、排序、搬迁等操作中大量使用移动语义。
2. 资源管理
   • 智能指针 std::unique_ptr：只能移动，不能拷贝。
3. 性能敏感代码
   • 大量临时对象或返回值对象：使用 std::move 或者直接返回局部对象，让编译器执行 NRVO（返回值优化）与移动结合。
4. 自定义容器或类
   • 需要高效管理内部大对象时实现移动构造/赋值。

四、实战案例：实现一个简单的“智能数组”

#include <iostream>
#include <utility>

class IntArray {
    int* data_;
    size_t size_;
public:
    IntArray(size_t sz = 0) : size_(sz) {
        data_ = sz ? new int[sz] : nullptr;
    }
    ~IntArray() { delete[] data_; }

    // 拷贝构造
    IntArray(const IntArray& other) : size_(other.size_) {
        data_ = new int[size_];
        std::copy(other.data_, other.data_ + size_, data_);
    }

    // 移动构造
    IntArray(IntArray&& other) noexcept : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }

    // 拷贝赋值
    IntArray& operator=(const IntArray& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new int[size_];
            std::copy(other.data_, other.data_ + size_, data_);
        }
        return *this;
    }

    // 移动赋值
    IntArray& operator=(IntArray&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }

    int& operator[](size_t idx) { return data_[idx]; }
    size_t size() const { return size_; }
};

IntArray makeArray(size_t n) {
    IntArray arr(n);
    for (size_t i = 0; i < n; ++i) arr[i] = static_cast<int>(i);
    return arr; // NRVO + 移动
}

int main() {
    IntArray a = makeArray(5); // 移动构造
    for (size_t i = 0; i < a.size(); ++i)
        std::cout << a[i] << " ";
    std::cout << std::endl;
}

关键点说明

• makeArray 返回局部对象，编译器会尝试 NRVO；即使没有 NRVO，return arr; 会触发移动构造。
• IntArray 的移动构造与赋值实现了资源的无缝转移，避免了深拷贝。

五、常见坑与最佳实践

场景	问题	解决方案
自定义移动构造	忘记 noexcept	加 noexcept，否则 STL 可能退回到复制
移动赋值	自己移动导致资源泄漏	先 delete 原资源，然后转移，最后置空源
传递给函数	传递 Rvalue 时多余拷贝	直接 std::move(obj) 或使用 && 参数
返回临时对象	NRVO 失效导致移动	确保返回对象为局部变量，或者手动 std::move

六、总结

移动语义为 C++ 提供了一种高效、可预期的资源管理方式，尤其在大对象、容器、RAII 模式下表现突出。掌握移动构造、移动赋值、std::move 的使用以及 noexcept 的重要性，是编写现代 C++ 高性能代码的基石。随着 C++17、C++20 的进一步完善，移动语义将继续深入到标准库和日常开发中，为软件性能与可维护性提供强有力的支持。

协程（coroutine）是C++20新加入的特性，它为实现轻量级的异步和生成器提供了统一的语法与运行时支持。与传统的回调或线程相比，协程能够在单个线程中暂停与恢复执行，避免了堆栈复制、锁竞争以及回调地狱等问题。本文将介绍协程的基本概念、关键类型以及一个完整的实现示例，帮助读者快速上手并将协程融入日常开发。

1. 协程的核心概念

1.1 生成器（Generator）

生成器是一种特殊的协程，能够按需返回一系列值。标准库提供了 `std::generator

`，但目前实现并不统一。一般实现思路是： “`cpp std::generator count(int n) { for (int i = 0; i ` 管理执行上下文。`Promise` 类型定义了协程的生命周期行为，包括： – `initial_suspend()`：协程入口处是否立即挂起 – `final_suspend()`：协程退出时是否挂起 – `get_return_object()`：返回给调用者的对象 – `return_value()` / `unhandled_exception()`：返回值与异常处理 ### 1.3 协程操作符 – `co_return`：结束协程并返回值 – `co_yield`：产生值并挂起协程 – `co_await`：等待另一个可等待对象（如 `std::future`、`std::chrono::duration` 等） ## 2. 协程的实现细节 下面以一个简单的异步任务为例，演示协程的完整实现。我们实现一个 `async_sleep` 函数，用于异步等待指定毫秒数，然后返回一个字符串。 “`cpp #include #include #include #include #include struct sleep_awaiter { std::chrono::milliseconds ms; std::coroutine_handle handle; bool await_ready() const noexcept { return false; } void await_suspend(std::coroutine_handle h) { handle = h; std::thread([ms = ms, h]{ std::this_thread::sleep_for(ms); h.resume(); }).detach(); } void await_resume() const noexcept {} }; auto async_sleep(std::chrono::milliseconds ms) -> std::future { struct promise_type { std::promise prom; auto get_return_object() { return prom.get_future(); } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void return_value(std::string val) { prom.set_value(std::move(val)); } void unhandled_exception() { prom.set_exception(std::current_exception()); } }; struct awaitable { std::coroutine_handle h; awaitable(std::coroutine_handle h) : h(h) {} bool await_ready() const noexcept { return false; } void await_suspend(std::coroutine_handle awaiting) { h.promise().prom.set_exception(std::make_exception_ptr(std::runtime_error(“not used”))); awaiting.resume(); } void await_resume() const noexcept {} }; struct coroutine { std::coroutine_handle h; coroutine(promise_type& p) : h(std::coroutine_handle ::from_promise(p)) {} std::future get_future() { return h.promise().prom.get_future(); } }; struct start { std::chrono::milliseconds ms; start(std::chrono::milliseconds ms) : ms(ms) {} auto operator co_await() { struct awaiter { std::chrono::milliseconds ms; awaiter(std::chrono::milliseconds ms) : ms(ms) {} bool await_ready() const noexcept { return false; } void await_suspend(std::coroutine_handle h) { std::thread([ms, h]{ std::this_thread::sleep_for(ms); h.resume(); }).detach(); } void await_resume() const noexcept {} }; return awaiter(ms); } }; struct task { struct promise_type; using handle_type = std::coroutine_handle ; handle_type coro; task(handle_type h) : coro(h) {} ~task() { if (coro) coro.destroy(); } std::future get_future() { return coro.promise().prom.get_future(); } }; struct promise_type { std::promise prom; auto get_return_object() { return task{std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void return_value(std::string val) { prom.set_value(std::move(val)); } void unhandled_exception() { prom.set_exception(std::current_exception()); } }; // coroutine body task coro = [&]()->task { co_await start(ms); co_return “Sleep done”; }(); return coro.get_future(); } “` 上述代码演示了： 1. **自定义 Awaiter**：实现了 `await_ready`、`await_suspend`、`await_resume` 三个成员，控制协程挂起与恢复。 2. **Promise 结构**：管理协程的返回值与异常，最终返回一个 `std::future` 给调用者。 3. **协程入口**：使用 `co_await` 等待 `sleep_awaiter` 的完成，然后 `co_return` 返回字符串。 使用示例： “`cpp int main() { auto fut = async_sleep(std::chrono::milliseconds(2000)); std::cout

C++20 引入了 std::format 标准库，它提供了类似 Python 的格式化语法，并且保证在编译时检查格式字符串和参数的一致性。相比于老式的 printf 或者字符串拼接，std::format 能够在运行时防止缓冲区溢出、格式错误和类型不匹配等常见问题。下面我们逐步介绍它的使用方法、常见技巧以及注意事项。

1. 依赖与准备

• 编译器：支持 C++20 的 GCC 10+、Clang 12+、MSVC 19.28+。
• 需要包含头文件 `#include `，并开启 C++20 标准（如 `-std=c++20`）。

#include <iostream>
#include <format>
#include <string>

提示：若使用的是 GCC 或 Clang 版本较低，可能需要安装 libfmt 并链接 -lfmt。

2. 基本用法

int main() {
    std::string name = "Alice";
    int age = 30;
    std::string msg = std::format("My name is {}, age {}.", name, age);
    std::cout << msg << '\n';
}

输出：

My name is Alice, age 30.

位置参数

可以使用 {0}, {1} 指定位置，支持重用：

auto s = std::format("{0} scored {1} points. {0} is happy.", "Bob", 95);

关键字参数

C++20 std::format 也支持关键字参数，类似 Python 的命名参数：

auto s = std::format("{name} has {score} points", std::format_args{fmt::arg("name", "Carol"), fmt::arg("score", 88)});

注意：fmt::arg 需要包含 #include <fmt/args.h>，在标准库中已简化。

3. 格式说明符

格式说明符位于 {} 内部，语法：

{[argument_index][!conversion][:format_spec]}

• !conversion：转义方式，常见有 !s、!r、!a（C++20 未实现 !r、!a，可使用 !s 进行字符串转义）。
• :format_spec：详细格式，例如对齐、宽度、填充、精度、进制等。

对齐与宽度

std::cout << std::format("{:10}", 42);     // 右对齐，宽度10
std::cout << std::format("{:<10}", 42);    // 左对齐
std::cout << std::format("{:^10}", 42);    // 居中

填充字符

std::cout << std::format("{:0>5}", 42);    // 00042

数值进制

std::cout << std::format("{:b}", 10);  // 1010
std::cout << std::format("{:o}", 10);  // 12
std::cout << std::format("{:X}", 255); // FF

浮点数精度

std::cout << std::format("{:.2f}", 3.14159);  // 3.14

4. 安全性与错误检测

编译时检查

std::format 在编译时会检查占位符数量与参数数量的一致性。例如：

std::format("{:d} {} {}", 10, "hello");

将导致编译错误，提示缺失参数。

运行时异常

如果格式字符串与参数类型不匹配，std::format 会抛出 std::format_error。

try {
    std::format("{:d}", "not an int");
} catch (const std::format_error& e) {
    std::cerr << "格式错误: " << e.what() << '\n';
}

5. 性能对比

与 sprintf/printf 或手动拼接相比，std::format 的性能略高，主要得益于：

• 避免了不安全的缓冲区操作。
• 编译期类型检查减少了运行时错误。
• 在大多数实现中使用了 fmt 库的高效算法。

6. 高级用法

自定义格式化器

可以为自定义类型实现 `std::formatter

` 以支持 `std::format`。 “`cpp struct Point { int x, y; }; template struct std::formatter { constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); } template auto format(const Point& p, FormatContext& ctx) { return format_to(ctx.out(), “Point({}, {})”, p.x, p.y); } }; int main() { Point p{3, 4}; std::cout (std::pmr::new_delete_resource()); int* arr = p.allocate(10, std::align_val_t{16}); “` ## 7. 常见陷阱 | 场景 | 错误 | 解决方案 | |——|——|———-| | 位置与关键字混用 | `std::format(“{0} {name}”, 1, fmt::arg(“name”,”A”))` | 只能使用一种方式，或者显式指定全部关键字参数。 | | 格式说明符错误 | `”{:d}”` 用于字符串 | 该格式符要求整数，使用 `{:s}` 或不使用说明符。 | | 格式化大型字符串 | 频繁拼接导致性能低 | 直接使用 `std::format` 或 `std::format_to` 写入缓冲区。 | ## 8. 小结 – `std::format` 是 C++20 标准提供的安全、强大、易用的字符串格式化工具。 – 它通过编译期检查、类型安全以及丰富的格式化选项，减少了许多传统 C 风格字符串操作的坑。 – 通过自定义 `formatter` 可以让任何类型都能轻松参与格式化，极大提升代码可读性与维护性。 建议在新项目中直接使用 `std::format` 替代老旧的字符串拼接与 `printf`，既能提升安全性，也能让代码更加现代化。

C++20 的协程（co_await、co_yield、co_return）为异步编程提供了更直观的语法。下面通过一个简单的示例，演示如何利用协程来实现一个异步任务调度器。

1. 协程类型概览

• promise_type：协程的承诺对象，负责管理协程的生命周期。
• handle_type：协程句柄，用于控制协程（挂起、恢复、销毁）。
• awaiter：co_await 的等待对象，定义 await_ready、await_suspend、await_resume 三个方法。

2. 简单的异步函数

#include <coroutine>
#include <iostream>
#include <thread>
#include <chrono>
#include <optional>

struct AsyncResult {
    struct promise_type {
        std::optional <int> value_;
        std::coroutine_handle <promise_type> caller_;

        AsyncResult get_return_object() {
            return AsyncResult{ std::coroutine_handle <promise_type>::from_promise(*this) };
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept {
            if (caller_) caller_.resume();
            return {};
        }
        void return_value(int v) { value_ = v; }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle <promise_type> coro_;
    AsyncResult(std::coroutine_handle <promise_type> h) : coro_(h) {}
    ~AsyncResult() { if (coro_) coro_.destroy(); }
};

struct AwaitableSleep {
    std::chrono::milliseconds dur_;
    AwaitableSleep(std::chrono::milliseconds d) : dur_(d) {}

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) {
        std::thread([h, dur = dur_]() {
            std::this_thread::sleep_for(dur);
            h.resume();
        }).detach();
    }

    void await_resume() const noexcept {}
};

AsyncResult async_task() {
    std::cout << "Task started\n";
    co_await AwaitableSleep{ std::chrono::seconds(2) };
    std::cout << "Task resumed after sleep\n";
    co_return 42;
}

int main() {
    auto task = async_task();
    // 模拟事件循环
    while (true) {
        if (!task.coro_.done()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        } else {
            std::cout << "Result: " << task.coro_.promise().value_.value() << '\n';
            break;
        }
    }
    return 0;
}

3. 代码解析

1. AsyncResult 包装协程句柄，提供了简洁的使用接口。
2. AwaitableSleep 是一个可等待对象，内部使用一个独立线程来实现非阻塞睡眠，睡眠结束后恢复协程。
3. async_task 展示了如何在协程内部 co_await 自定义等待对象，然后返回一个结果。
4. main 充当事件循环，持续检查协程是否完成。

4. 进一步扩展

• 任务调度：将 AwaitableSleep 换成网络 I/O 或数据库查询的 awaitable。
• 错误处理：在 promise_type 中实现 unhandled_exception，将异常信息传递给外部。
• 多任务：使用 `std::vector ` 进行并行任务管理。

通过上述示例，你可以快速掌握 C++20 协程的基本使用模式，为构建高性能异步框架奠定基础。

在过去的 C++ 版本中，头文件（header）一直是源文件之间共享声明和定义的主要手段。然而，头文件带来了编译时间长、命名冲突、依赖关系不透明等一系列问题。C++20 引入的模块（modules）机制，旨在解决这些痛点，为大型项目提供更高效、更安全的构建方式。本文将带你从零开始，深入理解 C++20 模块的概念、实现细节、使用方法以及常见陷阱。

1. 模块的基本概念

1.1 模块化的核心目标

• 减少编译时间：模块通过预编译方式（类似预编译头），避免重复编译相同代码。
• 防止命名冲突：模块导出的符号只在其导入范围内可见，减少全局命名污染。
• 明确依赖关系：模块文件之间的依赖关系在编译时可视化，提升维护性。

1.2 关键术语

• module interface unit：定义模块公共接口的源文件，使用 export 关键字暴露给外部。
• module implementation unit：仅在模块内部使用的源文件，不会被导出。
• module fragment：可与模块接口单元并列的文件，通常用作实现细节。
• import：C++20 引入的新关键字，用来导入模块。

2. 模块与头文件的区别

特性	传统头文件	C++20 模块
编译时预处理	必须包含每次编译	预编译一次，后续直接使用
命名冲突	可能导致全局冲突	仅在模块导入范围内
依赖可视化	隐式（由 include 决定）	明确（模块导入声明）
代码重用	通过头文件	通过模块 interface/implementation 单元

3. 模块的实现步骤

3.1 创建模块接口单元

// math/module.h
export module math; // 声明模块名

export namespace math {
    export int add(int a, int b);
    export double square(double x);
}

3.2 编写实现单元

// math/module.cpp
module math; // 引入自身模块
namespace math {
    int add(int a, int b) { return a + b; }
    double square(double x) { return x * x; }
}

3.3 导入模块

// main.cpp
import math; // 导入模块

#include <iostream>

int main() {
    std::cout << math::add(3, 5) << std::endl;
    std::cout << math::square(4.5) << std::endl;
}

3.4 编译指令

# 先编译模块接口单元
g++ -std=c++20 -fmodules-ts -c math/module.cpp -o math.o

# 编译主程序，链接模块对象文件
g++ -std=c++20 -fmodules-ts main.cpp math.o -o app

提示：不同编译器在实现模块支持时略有差异。GCC 12+、Clang 13+、MSVC 19.36+ 都提供了相应的编译选项。务必查阅对应编译器文档。

4. 常见坑与最佳实践

4.1 模块与头文件共存

• 不推荐：在同一项目中混用 #include 和 import，会导致不一致的编译行为。
• 做法：尽量把旧代码迁移到模块化结构，或者使用 预编译头（PCH） 统一处理。

4.2 export 关键字的位置

• export 必须紧挨在导出声明之前。
• 在模板定义中，export 需要放在模板声明前。

4.3 模块化的递归导入

• 警告：在模块内部导入同一模块会导致编译错误。
• 解决办法：使用 分层设计，把公共 API 与实现拆分到不同模块。

4.4 编译缓存

• 由于模块接口编译后会生成 .pcm（预编译模块缓存）文件，务必在 CI 或多机器编译环境中同步此缓存，以避免重复编译。

5. 进阶主题

5.1 模块的可见性控制

• export 关键字只在模块的外部可见。
• 通过 private 关键字或 module 内部 namespace 可以隐藏实现细节。

5.2 预编译模块缓存（PCM）

• 编译器在首次编译模块接口单元时生成 .pcm，随后可直接引用。
• 适当管理 .pcm 目录，可显著提升构建速度。

5.3 模块与标准库的集成

• 大多数编译器已为标准库提供模块化版本（如 std 模块）。
• 在项目中使用 import std; 替代 `#include ` 可以进一步减少头文件冗余。

6. 结语

C++20 模块为 C++ 生态注入了久违的模块化能力，能够显著提升大规模项目的编译效率和代码可维护性。虽然在实际使用中仍需兼顾编译器实现差异和团队现有代码结构，但只要遵循规范与最佳实践，模块化将成为你开发 C++ 程序的有力武器。愿你在模块化的旅程中，写出更快、更干净、更可靠的 C++ 代码。

在 C++17 之前，constexpr 只是一种强制把变量声明为常量的方式，几乎只能用于简单的数值初始化。但从 C++17 开始，constexpr 的语义被显著扩展，成为一种能够在编译时计算表达式、执行递归算法、甚至实现完整的编译时数据结构的强大工具。下面我们将系统地探讨 constexpr 在 C++17 中的变化，举例说明它如何改变程序设计，并给出实用的使用建议。

1. constexpr 的语义演变

• constexpr 函数

  • 之前只能返回字面量，不能包含循环、递归或局部静态变量。
  • C++17 允许 constexpr 函数内部使用 if、switch、循环，并且可以递归。
  • 这意味着我们可以在编译时实现 Fibonacci、阶乘、甚至更复杂的动态规划。

• constexpr 变量

  • 依旧必须在编译时可求值。
  • 现在可以是任何可在编译期初始化的对象，包括 STL 容器（std::array、std::initializer_list 等）以及自定义类。

• constexpr 结构体

  • 可以拥有非静态数据成员，并在 constexpr 构造函数中初始化。
  • 这使得在编译时构造复杂的结构变得可行。

2. 编译时常量表达式的优势

1. 性能提升
   • 编译时计算消除运行时开销，尤其在数学密集型或查询密集型代码中效果明显。
2. 类型安全
   • 由于编译期求值，错误会在编译阶段被捕获，例如数组越界、非法指针解引用等。
3. 代码可读性与可维护性
   • 用 constexpr 把“常量”与“计算”清晰分离，代码更易理解。
4. 模板元编程简化
   • 传统模板元编程需要大量递归模板实例化，constexpr 让这些逻辑更贴近普通函数，减少编译时间。

3. 实战案例

3.1 计算斐波那契数列

constexpr unsigned int fib(unsigned int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

static_assert(fib(10) == 55, "Fib错误");
constexpr unsigned int fib10 = fib(10); // 在编译时求值

3.2 编译时字符串拼接

#include <string_view>

constexpr std::string_view operator+(std::string_view a, std::string_view b) {
    std::string_view result;
    // 简化演示：实际上需要自定义容器来存储拼接结果
    return result;
}

注意：C++20 引入 std::string_view 的拼接 constexpr 支持，使得编译时字符串操作更易实现。

3.3 constexpr STL 容器

constexpr std::array<int, 5> arr{1, 2, 3, 4, 5};
constexpr auto sum = [](){
    int s = 0;
    for (int v : arr) s += v;
    return s;
}();
static_assert(sum == 15);

4. 需要注意的陷阱

• constexpr 语句块
  • 虽然允许循环，但编译器可能仍会在运行时执行，除非确定在编译时可解。
• 递归深度
  • 递归 constexpr 函数的深度受编译器限制（默认约 1024），超过可能导致编译错误。
• 全局变量
  • 对于使用 constexpr 初始化的全局对象，必须在所有 TU 里显式 inline 或 consteval（C++20）声明，否则可能导致多重定义。
• 异常
  • constexpr 函数内部不允许抛出异常，若抛出会导致编译错误。

5. 结合 C++20 的 consteval 与 constinit

• consteval 用于强制函数在编译期求值，任何尝试在运行时调用都会报错。
• constinit 用于标记全局变量必须在编译时初始化，以避免未定义的初始化顺序。

6. 小结

C++17 将 constexpr 从一种简单的“常量”标记演变为一种完整的编译期计算工具。它让我们能够在编译时完成复杂计算、构造数据结构、并在不牺牲可读性与维护性的前提下获得性能提升。熟练掌握 constexpr 的语义与使用场景，将极大提升 C++ 开发者在性能优化和程序安全方面的能力。

在C++20中，协程（coroutine）提供了一个极其简洁而强大的异步编程模型。与传统的线程或回调相比，协程能够让你以同步的写法描述异步逻辑，同时保持代码的可读性和可维护性。本文将以“网络请求异步下载”为例，演示如何使用C++20协程实现一个简易的异步下载器，并讨论其优势与常见陷阱。

1. 协程的基本概念

• co_await：挂起协程，等待一个 awaitable 对象完成。
• co_yield：产生一个值并挂起，类似生成器。
• co_return：返回值并结束协程。
• awaitable：任何可以被 co_await 的类型，必须实现 await_ready、await_suspend 和 await_resume 三个成员函数。

协程本身并不创建新线程，协程的挂起和恢复是由调度器决定的，通常在事件循环（event loop）或线程池中完成。

2. 准备工作：简易异步网络请求库

下面我们使用一个假想的异步 HTTP 客户端 AsyncHttpClient，其 get 方法返回一个 std::future<std::string>。在真实项目中，你可以用 libcurl 的异步接口、Boost.Beast 或者自定义基于 epoll/kqueue 的 I/O 事件循环。

#include <future>
#include <string>
#include <chrono>
#include <thread>
#include <iostream>

class AsyncHttpClient {
public:
    std::future<std::string> get(const std::string& url) {
        return std::async(std::launch::async, [url]() {
            // 模拟网络延迟
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
            return std::string("Response from ") + url;
        });
    }
};

3. 协程包装器：future → awaitable

C++20 标准库没有直接提供将 std::future 转为 awaitable 的工具。我们手动实现一个轻量级的包装器：

#include <coroutine>
#include <future>

template<typename T>
struct FutureAwaitable {
    std::future <T> fut;

    bool await_ready() const noexcept { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }

    void await_suspend(std::coroutine_handle<> h) {
        std::thread([h, f = std::move(fut)]() mutable {
            f.wait();
            h.resume();
        }).detach();
    }

    T await_resume() { return fut.get(); }
};

template<typename T>
FutureAwaitable <T> to_awaitable(std::future<T> f) {
    return FutureAwaitable <T>{ std::move(f) };
}

说明

• await_ready 检查 future 是否已完成，若已完成则不挂起。
• await_suspend 在一个独立线程中等待 future，然后恢复协程。实际项目可用事件驱动的完成机制替代。
• await_resume 在协程恢复时返回 future 的结果。

4. 协程函数实现

下面是一个协程 download_file，接收 URL 并返回下载内容：

#include <string>
#include <coroutine>
#include <iostream>

struct DownloadTask {
    struct promise_type {
        std::string result;
        DownloadTask get_return_object() { return {std::coroutine_handle <promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_value(std::string r) { result = std::move(r); }
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle <promise_type> coro;

    std::string get() { return coro.promise().result; }
    ~DownloadTask() { if (coro) coro.destroy(); }
};

DownloadTask download_file(AsyncHttpClient& client, const std::string& url) {
    std::string resp = co_await to_awaitable(client.get(url));
    co_return resp;
}

关键点

• DownloadTask 的 promise_type 简单地保存结果。initial_suspend 与 final_suspend 均返回 std::suspend_never，表示协程在入口和出口都不挂起。实际场景中可根据需要改为 std::suspend_always。
• co_await 的 awaitable 是上面定义的 FutureAwaitable。

5. 调度与事件循环

在本示例中，我们直接等待协程完成。真实应用往往需要一个事件循环，类似 Node.js 的 libuv。下面给出一个极简事件循环，处理协程挂起/恢复：

#include <queue>
#include <functional>

class EventLoop {
public:
    void schedule(std::function<void()> task) { tasks.push(std::move(task)); }
    void run() {
        while (!tasks.empty()) {
            auto t = std::move(tasks.front());
            tasks.pop();
            t();
        }
    }
private:
    std::queue<std::function<void()>> tasks;
};

将 FutureAwaitable 的 await_suspend 修改为使用 EventLoop：

void await_suspend(std::coroutine_handle<> h) {
    // 将恢复操作加入事件循环
    event_loop.schedule([h](){ h.resume(); });
}

这样，所有挂起的协程都交由事件循环调度，避免了每次挂起都创建新线程。

6. 完整示例

#include <iostream>
#include <future>
#include <coroutine>
#include <string>
#include <thread>
#include <chrono>
#include <queue>
#include <functional>

// 事件循环
class EventLoop {
public:
    void schedule(std::function<void()> task) { tasks.push(std::move(task)); }
    void run() {
        while (!tasks.empty()) {
            auto t = std::move(tasks.front());
            tasks.pop();
            t();
        }
    }
private:
    std::queue<std::function<void()>> tasks;
};

EventLoop g_loop;

// 异步 HTTP 客户端
class AsyncHttpClient {
public:
    std::future<std::string> get(const std::string& url) {
        return std::async(std::launch::async, [url]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
            return std::string("Response from ") + url;
        });
    }
};

// Future → Awaitable
template<typename T>
struct FutureAwaitable {
    std::future <T> fut;

    bool await_ready() const noexcept { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }

    void await_suspend(std::coroutine_handle<> h) {
        // 用事件循环恢复
        g_loop.schedule([h](){ h.resume(); });
    }

    T await_resume() { return fut.get(); }
};

template<typename T>
FutureAwaitable <T> to_awaitable(std::future<T> f) { return FutureAwaitable<T>{std::move(f)}; }

// 协程任务
struct DownloadTask {
    struct promise_type {
        std::string result;
        DownloadTask get_return_object() { return {std::coroutine_handle <promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_value(std::string r) { result = std::move(r); }
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle <promise_type> coro;
    std::string get() { return coro.promise().result; }
    ~DownloadTask() { if (coro) coro.destroy(); }
};

DownloadTask download_file(AsyncHttpClient& client, const std::string& url) {
    std::string resp = co_await to_awaitable(client.get(url));
    co_return resp;
}

int main() {
    AsyncHttpClient client;

    auto task = download_file(client, "https://example.com");
    g_loop.schedule([t=std::move(task)]() mutable {
        std::cout << "Download finished: " << t.get() << std::endl;
    });

    g_loop.run(); // 进入事件循环
    return 0;
}

运行结果

Download finished: Response from https://example.com

7. 优点与注意事项

优点	说明
代码简洁	co_await 让异步代码呈现同步写法
可组合性	协程可以像普通函数一样被组合、传参
资源友好	只要有事件循环，协程本身不消耗线程资源

注意	说明
awaitable 设计	必须正确实现 await_ready / await_suspend / await_resume，否则可能导致死锁
事件循环	协程挂起时应加入事件循环，避免使用 std::thread 阻塞
错误传播	unhandled_exception 必须妥善处理，否则会直接终止程序

8. 小结

本文通过一个简易的网络下载示例，演示了 C++20 协程的基本使用方法。通过 FutureAwaitable 将 std::future 转为 awaitable，结合事件循环，你可以轻松实现高性能的异步 I/O。随着 C++23 引入的 std::ranges::subrange 与 std::experimental::generator，协程的生态将进一步完善，成为构建高并发应用的核心技术之一。

在现代C++（C++11及以后）中，移动语义（Move Semantics）是实现高性能程序的重要工具。它通过将资源所有权从一个对象转移到另一个对象，避免了不必要的深拷贝，从而显著提升了效率。本文将从移动语义的基本概念、实现方式、常见使用场景以及高级技巧等方面进行系统阐述，并通过实例代码帮助读者快速上手。

---

一、移动语义的核心思想

1.1 什么是移动语义？

移动语义本质上是“转移所有权”的概念。与拷贝（复制）不同，移动不需要复制资源，而是简单地把资源指针或引用转移过去，原对象变成“空”或“失效”状态。

1.2 为什么需要移动语义？

• 性能优化：大对象、动态分配内存、文件句柄、网络连接等资源复制代价高，移动可消除冗余拷贝。
• 资源管理：与RAII（Resource Acquisition Is Initialization）配合，避免资源泄漏。

1.3 移动语义与拷贝语义的区别

	拷贝构造	移动构造
作用	复制对象状态	转移对象所有权
成本	高（复制）	低（指针转移）
需要的接口	T(const T&)	T(T&&)
对原对象状态的影响	无	原对象变为安全但未定义状态

---

二、实现移动语义的基本模式

2.1 移动构造函数

class MyBuffer {
public:
    MyBuffer(size_t n) : size_(n), data_(new int[n]) {}
    ~MyBuffer() { delete[] data_; }

    // 拷贝构造（默认）
    MyBuffer(const MyBuffer&) = delete;          // 禁用拷贝

    // 移动构造
    MyBuffer(MyBuffer&& other) noexcept
        : size_(other.size_), data_(other.data_) {
        other.size_ = 0;
        other.data_ = nullptr;
    }

    // 移动赋值
    MyBuffer& operator=(MyBuffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = other.data_;
            other.size_ = 0;
            other.data_ = nullptr;
        }
        return *this;
    }

private:
    size_t size_;
    int* data_;
};

2.2 noexcept 的重要性

移动构造函数和移动赋值运算符应尽量标记为 noexcept，因为在容器（如 std::vector）中，如果移动构造抛异常，将导致元素的移动失败，容器会退回到拷贝构造，失去性能优势。

2.3 防止意外拷贝

默认情况下，编译器会生成拷贝构造和拷贝赋值运算符。若类只实现移动语义，最好显式删除拷贝相关接口，避免误用。

---

三、移动语义的常见使用场景

3.1 标准容器

std::vector、std::string、std::unordered_map 等容器在内部利用移动语义实现元素的扩容、排序等操作。用户只需确保自己的元素类型实现了移动构造即可。

3.2 函数返回大对象

std::string getLargeString() {
    std::string s(1000000, 'x');
    return s; // NRVO 或移动构造
}

3.3 资源包装类

• 文件句柄：std::unique_ptr<std::FILE, decltype(&std::fclose)>。
• 网络套接字：自定义 Socket 类，封装 int fd 并实现移动。

3.4 std::move 的正确使用

MyBuffer buf1(1024);
MyBuffer buf2 = std::move(buf1); // 明确表示移动

注意：std::move 只是类型转换，并不执行移动。移动行为发生在构造/赋值时。

---

四、移动语义的高级技巧

4.1 自定义移动逻辑

有时需要在移动过程中执行额外操作，例如记录日志、更新引用计数等。可以在移动构造函数中加入自定义代码：

MyBuffer(MyBuffer&& other) noexcept
    : size_(other.size_), data_(other.data_) {
    // 自定义：更新统计
    Logger::incrementMoves();
    other.size_ = 0;
    other.data_ = nullptr;
}

4.2 延迟移动（Lazily Move）

在需要在容器中频繁搬迁元素时，可以使用 std::move_if_noexcept：

std::vector <T> vec;
vec.push_back(std::move_if_noexcept(obj));

如果 T 的移动构造不是 noexcept，会退回使用拷贝构造。

4.3 混合拷贝与移动的类

某些类既需要拷贝也需要移动，例如自定义的 String 类可以同时实现：

String(const String& other);   // 拷贝
String(String&& other) noexcept; // 移动

4.4 与智能指针结合

• std::unique_ptr 是不可拷贝但可移动的典型示例。
• std::shared_ptr 通过引用计数实现共享语义；移动 shared_ptr 仅转移计数指针。

---

五、常见误区与调试技巧

5.1 错误地删除拷贝构造

如果仅删除拷贝构造，编译器将不再生成默认拷贝构造，但如果有其他代码（如 `std::vector

`）尝试拷贝对象，就会报错。确保类声明与使用场景一致。 ### 5.2 忘记 `noexcept` 在容器内部使用移动构造时，如果移动构造抛异常，容器会退回拷贝，导致性能下降甚至异常抛出。一定要标记 `noexcept`。 ### 5.3 `std::move` 的误用 `std::move` 会让对象进入“失效”状态，但不一定立即删除资源。若在错误的生命周期使用失效对象，程序行为未定义。避免在移动后立即使用原对象，除非先判断其有效性。 ### 5.4 调试移动 使用 `-fsanitize=address -fsanitize=undefined` 或 Valgrind 可以捕捉因移动导致的悬挂指针、双重释放等错误。 — ## 六、结语 移动语义是 C++11 以后性能优化的重要工具。通过正确实现移动构造和移动赋值，合理标记 `noexcept`，并结合智能指针和容器的特性，程序员可以在不牺牲安全性的前提下，显著提升代码的运行效率。掌握移动语义不仅是提高性能的手段，更是深入理解现代 C++ 语义的关键一步。希望本文能帮助你在日常编码中更好地运用移动语义，写出更高效、更优雅的 C++ 代码。