stdcpp

Move semantics, introduced with C++11, revolutionized resource management by allowing efficient transfer of ownership instead of costly deep copies. When an object is no longer needed in its original location, the compiler can “move” its internal state to a new object, essentially swapping pointers and nullifying the source. This mechanism shines in scenarios such as returning large containers from functions or handling temporary objects in modern algorithms. To enable move semantics, a class should provide a move constructor and move assignment operator, typically defined as Class(Class&&) noexcept and Class& operator=(Class&&) noexcept. The noexcept specifier hints to the compiler that these operations won’t throw, allowing further optimizations like avoiding exception safety overhead. Moreover, standard containers like std::vector and std::string automatically use move semantics, leading to significant performance gains in high‑throughput applications. Understanding when and how to implement these special member functions is crucial for writing efficient, modern C++ code.

在 C++17 之后，std::variant 成为实现类型安全多态的一种强大工具。与传统的基类/指针/虚函数机制相比，std::variant 可以在编译期捕获错误，避免运行时的 dynamic_cast 开销，并且可以与 std::visit 组合实现模式匹配式的处理。下面从使用场景、核心概念、典型示例以及性能与可维护性四个方面来剖析 std::variant 的优势与使用技巧。

1. 典型使用场景

1. 事件系统
   事件往往携带不同类型的数据，如鼠标事件、键盘事件、定时器事件等。使用 std::variant 可以将所有事件类型封装到同一个容器中，便于统一队列与分发。

2. 解析器结果
   语法树的叶子节点可能是数字、字符串、布尔值等不同类型，std::variant 让节点类型清晰且安全。

3. 配置文件
   配置项的值类型多样（字符串、数值、布尔、数组等），std::variant 能在解析阶段就完成类型判断，后续使用更直观。

2. 核心概念

关键字	作用
std::variant<Ts...>	类型安全的联合体，内部会存放 Ts 中之一
`std::get
(v)| 访问内部值，若类型不匹配会抛std::bad_variant_access`
`std::get_if
(&v)| 访问内部值，若类型不匹配返回nullptr`
std::visit(visitor, v)	对当前存放的值调用 visitor 的对应 operator()
`std::holds_alternative
(v)| 判断当前是否为T` 类型
std::monostate	空类型，用于占位或表示空值

3. 典型示例

#include <variant>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>

// 事件类型
struct MouseEvent { int x, y; };
struct KeyEvent   { int key; };
struct TimerEvent { int id; };

using Event = std::variant<MouseEvent, KeyEvent, TimerEvent>;

void handleEvent(const Event& ev) {
    std::visit([](auto&& e){
        using T = std::decay_t<decltype(e)>;
        if constexpr (std::is_same_v<T, MouseEvent>) {
            std::cout << "Mouse at (" << e.x << ", " << e.y << ")\n";
        } else if constexpr (std::is_same_v<T, KeyEvent>) {
            std::cout << "Key pressed: " << e.key << '\n';
        } else if constexpr (std::is_same_v<T, TimerEvent>) {
            std::cout << "Timer expired: " << e.id << '\n';
        }
    }, ev);
}

int main() {
    std::vector <Event> events = {
        MouseEvent{100, 200},
        KeyEvent{42},
        TimerEvent{7}
    };

    for(const auto& e : events)
        handleEvent(e);
}

上述代码演示了如何在事件队列中统一存放不同类型的事件，并通过 std::visit 进行类型匹配。由于 std::variant 的类型信息在编译期已知，编译器能进行更严格的检查，避免了 dynamic_cast 的运行时开销。

4. 性能与可维护性

• 大小与对齐：std::variant 的大小是所有成员类型中最大者加上一个 unsigned char（用于记录当前索引）。如果成员类型差异较大，需注意内存占用。
• 移动/复制：std::variant 默认实现移动与复制构造/赋值，且每种成员类型需要满足对应的移动/复制语义。
• 错误提示：编译错误会指出不匹配的 operator()，有助于快速定位逻辑错误。
• 代码简洁：使用 std::visit 与 lambda 表达式组合，可避免显式的 if-else 或 switch。

5. 进阶技巧

1. 自定义 Visitor
   若需要在多次访问时复用同一逻辑，可以实现一个多重继承的 Visitor，例如：

   struct MouseVisitor {
       void operator()(const MouseEvent& e) const { /* ... */ }
   };
   struct KeyVisitor {
       void operator()(const KeyEvent& e) const { /* ... */ }
   };
   using FullVisitor = std::variant<MouseVisitor, KeyVisitor>;

2. 结合 std::any 与 std::variant
std::any 用于未知类型的容器，而 std::variant 用于已知且有限的类型集合。两者可配合使用，在动态插件系统中先用 std::any 接收，再通过 std::variant 进行类型安全处理。

3. 自定义错误消息
   std::visit 的捕获块可以抛出自定义异常，携带更友好的错误信息，提升调试体验。

6. 小结

std::variant 在现代 C++ 中提供了类型安全、编译期检查、与 std::visit 配合的多态实现方案。相较传统的继承+虚函数模式，std::variant 在性能、可读性以及错误检测方面具有明显优势。掌握其核心用法后，可在事件系统、解析器、配置管理等多种场景中大幅提升代码质量与维护效率。

在网络编程中，协议解析往往需要处理流式数据、处理不完整包、支持回退和错误恢复。使用有限状态机（Finite State Machine, FSM）是构建可靠协议解析器的常用技巧。下面将演示如何在C++中使用FSM实现一个简化的自定义二进制协议解析器，并讨论关键设计要点。

1. 协议定义

假设我们的协议结构如下：

字段	长度	说明
头部标识	2字节	固定值 0xAA55
消息类型	1字节	例如 0x01（文本）/0x02（二进制）
数据长度	2字节	表示后续数据字段的字节数
数据	可变	消息体
校验和	1字节	简单的 XOR 校验

2. 状态机枚举

enum class ParserState {
    WAIT_HEADER,      // 等待头部
    WAIT_TYPE,        // 等待消息类型
    WAIT_LENGTH,      // 等待长度字段
    WAIT_PAYLOAD,     // 等待数据字段
    WAIT_CHECKSUM     // 等待校验和
};

3. 解析器类

#include <cstdint>
#include <vector>
#include <stdexcept>
#include <iostream>

class ProtocolParser {
public:
    ProtocolParser() : state(ParserState::WAIT_HEADER), headerCount(0) {}

    // 逐字节调用
    void feed(uint8_t byte) {
        switch(state) {
            case ParserState::WAIT_HEADER:
                handleHeader(byte);
                break;
            case ParserState::WAIT_TYPE:
                type = byte;
                state = ParserState::WAIT_LENGTH;
                break;
            case ParserState::WAIT_LENGTH:
                lengthBuffer.push_back(byte);
                if(lengthBuffer.size() == 2) {
                    payloadLength = (lengthBuffer[0] << 8) | lengthBuffer[1];
                    payload.clear();
                    payloadBuffer.clear();
                    state = ParserState::WAIT_PAYLOAD;
                }
                break;
            case ParserState::WAIT_PAYLOAD:
                payload.push_back(byte);
                if(payload.size() == payloadLength) {
                    state = ParserState::WAIT_CHECKSUM;
                }
                break;
            case ParserState::WAIT_CHECKSUM:
                checksum = byte;
                if(checksumValid()) {
                    processMessage();
                } else {
                    std::cerr << "Checksum error!\n";
                }
                reset();
                break;
        }
    }

private:
    ParserState state;
    int headerCount;          // 用于匹配两个字节头部
    uint8_t type;
    std::vector <uint8_t> lengthBuffer; // 收集两字节长度
    uint16_t payloadLength;
    std::vector <uint8_t> payload;
    uint8_t checksum;

    void handleHeader(uint8_t byte) {
        static const uint8_t HEADER_BYTES[2] = {0xAA, 0x55};
        if(byte == HEADER_BYTES[headerCount]) {
            ++headerCount;
            if(headerCount == 2) {
                state = ParserState::WAIT_TYPE;
                headerCount = 0;
            }
        } else {
            // 非法头部，重置
            headerCount = 0;
        }
    }

    bool checksumValid() const {
        uint8_t calc = type;
        for(uint8_t b : lengthBuffer) calc ^= b;
        for(uint8_t b : payload) calc ^= b;
        return calc == checksum;
    }

    void processMessage() {
        std::cout << "Message received, type: 0x" << std::hex << static_cast<int>(type) << ", length: " << std::dec << payloadLength << "\n";
        // 根据 type 进一步处理 payload
    }

    void reset() {
        state = ParserState::WAIT_HEADER;
        headerCount = 0;
        type = 0;
        lengthBuffer.clear();
        payloadLength = 0;
        payload.clear();
        checksum = 0;
    }
};

4. 关键设计点

1. 字节级输入
   解析器采用逐字节 feed 接口，方便与网络 I/O (如 recv 或 asio::async_read_some) 集成。任何时间点接收到的新字节都会被及时处理。

2. 状态机驱动
   状态机把解析流程拆成清晰的阶段，每个阶段只处理自己的数据。若出现错误（如校验和失败），可以直接重置到 WAIT_HEADER，不必担心回退到上一阶段。

3. 可扩展性
   若协议增加新的字段，只需在相应状态中插入处理逻辑，保持状态机的整体结构不变。若要支持多种协议，可将 ProtocolParser 作为基类，派生类实现 processMessage。

4. 异常安全
   本示例中没有抛出异常，但在生产环境中建议在关键路径抛出自定义异常并在上层捕获，或者使用错误码返回。

5. 性能优化

   • 对于大 payload，避免多次 std::vector::push_back；可以预留空间 payload.reserve(payloadLength)。
   • 计算校验和时，可用位运算快速完成。
   • 如果使用多线程，注意加锁或使用线程安全的 I/O。

5. 与异步框架结合

以下示例展示如何在 Boost.Asio 中使用该解析器：

void handleRead(const boost::system::error_code& ec, std::size_t bytes_transferred,
                std::shared_ptr <ProtocolParser> parser, std::shared_ptr<asio::ip::tcp::socket> socket,
                std::vector <uint8_t> buffer) {
    if(ec) return;
    for(size_t i = 0; i < bytes_transferred; ++i) {
        parser->feed(buffer[i]);
    }
    socket->async_read_some(asio::buffer(buffer),
                            std::bind(handleRead, std::placeholders::_1, std::placeholders::_2,
                                      parser, socket, buffer));
}

通过上述方法，即使网络分片、粘包也能被正确解析，保持协议层的健壮性。

6. 小结

• FSM 是处理流式网络协议的天然工具，能够分阶段解析数据、优雅处理错误。
• 逐字节解析 提升了容错性，特别是在 TCP 粘包/拆包场景。
• 关注 状态机设计、错误处理 和 性能，即可构建高效可靠的协议解析器。

希望这份示例能帮助你在项目中快速搭建一个基于 FSM 的网络协议解析器。祝编码愉快！

C++23 continues the momentum of modern C++ by refining and extending features that were introduced in earlier standards. Developers who have embraced concepts in C++20 and the powerful ranges library will find new utilities that make generic programming more expressive and safer. Additionally, the coroutine library receives several improvements that simplify asynchronous programming without sacrificing performance. This article gives an overview of the most impactful additions, demonstrates how they can be used in real code, and discusses the practical benefits they bring to contemporary C++ projects.

1. Enhanced Concepts and the std::concept Interface
C++23 adds the std::concept keyword, allowing developers to expose concepts directly as library types. Instead of defining a concept as a separate entity, you can write:

template<class T>
concept std::default_initializable = requires { T{}; };

This makes concepts discoverable by type introspection tools and easier to combine with std::requires. The standard library now provides many ready‑made concepts like std::integral, std::copyable, and std::swappable, which can be composed to enforce stricter constraints on templates.

2. Ranges Refinement: Views, Filters, and Transforms
The ranges library gets two major new views:

• std::views::common – converts a view into one that can be stored in a std::vector or used with std::ranges::for_each.
• std::views::transform_reduce – a lazy, one‑pass transform‑reduce that combines std::views::transform and std::views::reduce.

A common pattern in performance‑critical code is to process a sequence of objects, filter them, and accumulate a result. With C++23 ranges you can write:

auto sum = std::ranges::accumulate(
    std::views::transform_reduce(
        std::views::filter([](auto&& v){ return v.is_active; }),
        std::views::transform([](auto&& v){ return v.score; })
    ),
    0
);

This approach is both expressive and zero‑overhead, as the entire pipeline is evaluated lazily.

3. Coroutine Enhancements: std::suspend_always, std::suspend_never, and std::suspend_current
C++23 introduces three new suspend points:

• std::suspend_always – always suspends.
• std::suspend_never – never suspends.
• std::suspend_current – suspends only if the coroutine has been resumed previously.

These helpers enable fine‑grained control over coroutine scheduling. For example, a coroutine that lazily streams database rows can suspend only after the first read:

co_await std::suspend_current{};

This avoids unnecessary context switches for initial entry into the coroutine.

4. std::expected – A Safer Alternative to Exceptions
While exceptions are still available, std::expected<T, E> provides a type‑safe, zero‑alloc mechanism for propagating errors. A function that might fail can return:

std::expected<int, std::string> parse_int(const std::string& str);

Consumers then check expected.has_value() or use pattern matching via if (auto val = ex.value_or([]{ return 0; })). This leads to clearer control flow and can be combined with ranges and concepts to write robust, exception‑free code.

5. Miscellaneous Additions

• std::format now supports locale‑aware formatting for numbers and dates.
• std::bit_cast becomes a constexpr function, enabling compile‑time reinterpretation of types.
• The std::filesystem API gets the permissions API extended to support std::filesystem::perms::remove_group etc.

Conclusion
C++23 consolidates the powerful abstractions introduced in C++20 and makes them more ergonomic. By leveraging concepts, ranges, and coroutine helpers, developers can write code that is not only more readable but also easier to maintain and less error‑prone. As the ecosystem continues to evolve, adopting these new features will position your projects at the forefront of modern C++ development.

在现代 C++ 开发中，单例模式仍然是一种常用的设计模式，尤其是在需要共享资源（如日志系统、配置管理器、数据库连接池等）时。虽然传统的单例实现可以通过双重检查锁定（Double-Check Locking）等方式完成，但这些实现往往不够直观，且在多线程环境下容易出现细微的 race 条件。自 C++11 起，标准库提供了线程安全的 std::call_once 以及 std::once_flag，再配合 std::unique_ptr 或直接返回静态对象，便可以实现极为简洁且线程安全的懒汉式单例。下面给出一个完整的实现示例，并演示如何在 C++17 环境下使用。

1. 单例接口与实现

// Singleton.h
#pragma once
#include <memory>
#include <mutex>

template <typename T>
class Singleton {
public:
    // 获取单例实例的引用
    static T& instance() {
        std::call_once(initFlag_, []() {
            instance_.reset(new T());
        });
        return *instance_;
    }

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

protected:
    Singleton() = default;
    virtual ~Singleton() = default;

private:
    static std::once_flag initFlag_;
    static std::unique_ptr <T> instance_;
};

// Singleton.cpp
#include "Singleton.h"

template <typename T>
std::once_flag Singleton <T>::initFlag_;

template <typename T>
std::unique_ptr <T> Singleton<T>::instance_;

说明

• std::call_once 只会在第一次调用时执行传入的 lambda，后续调用不再触发。
• std::once_flag 用来保证 call_once 的一次性执行。
• std::unique_ptr 保证了单例对象在程序退出时的正确析构。
• 通过把 instance_ 声明为 static，可以实现跨线程共享。

2. 业务类继承单例

// Logger.h
#pragma once
#include "Singleton.h"
#include <iostream>
#include <string>
#include <chrono>
#include <iomanip>

class Logger : public Singleton <Logger> {
    friend class Singleton <Logger>; // 让 Singleton 能够访问 Logger 的构造函数

public:
    void log(const std::string& message) {
        auto now = std::chrono::system_clock::now();
        auto time = std::chrono::system_clock::to_time_t(now);
        std::cout << "[" << std::put_time(std::localtime(&time), "%F %T") << "] " << message << std::endl;
    }

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

说明

• Logger 的构造函数是私有的，只有 `Singleton ` 通过 `friend` 能够访问。
• Singleton 的 instance() 函数返回 Logger&，可以在任何地方直接使用。

3. 在多线程环境中使用单例

// main.cpp
#include "Logger.h"
#include <thread>
#include <vector>

void worker(int id) {
    Logger::instance().log("Thread " + std::to_string(id) + " started.");
    // 业务逻辑...
    Logger::instance().log("Thread " + std::to_string(id) + " finished.");
}

int main() {
    const int threadCount = 8;
    std::vector<std::thread> threads;

    for (int i = 0; i < threadCount; ++i) {
        threads.emplace_back(worker, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    Logger::instance().log("All threads completed.");
    return 0;
}

运行上述程序时，可以看到所有线程都共享同一个 Logger 实例，且日志输出顺序不受线程调度的影响（虽然消息的时序可能因调度而异，但单例的初始化只会在第一次调用 instance() 时执行一次，且不会产生任何 race 条件）。

4. 优点与适用场景

1. 线程安全 – std::call_once 确保了懒汉式初始化的原子性。
2. 延迟加载 – 只有在第一次使用时才创建实例，避免不必要的资源占用。
3. 易于维护 – 单例实现被封装在 Singleton 模板中，业务类只需继承即可。
4. 自动销毁 – std::unique_ptr 保证在程序结束时自动析构，避免内存泄漏。

常见的适用场景包括：

• 日志系统（如上例）
• 配置管理器
• 线程池
• 数据库连接池
• 缓存管理器

5. 可能的改进

虽然上述实现已经满足大多数需求，但在一些特殊场景下可能需要做进一步优化：

场景	解决方案
单例需要延迟销毁	使用 std::shared_ptr 并手动 reset()
单例初始化需要额外参数	在 instance() 前提供 init() 函数，或使用工厂模式
单例需要在多进程共享	需要使用进程间共享内存或 mmap 进行映射，C++ 标准库并不直接支持

6. 结语

通过结合 std::call_once、std::once_flag 与 std::unique_ptr，C++17 可以轻松实现线程安全的懒汉式单例模式。相比传统的双重检查锁定（Double-Check Locking），这种方式更为简洁、可读且安全。只需将业务类继承自 `Singleton

` 并通过 `Logger::instance()` 访问实例，即可在多线程程序中无忧地共享资源。

在 C++20 标准中，概念（Concepts）被引入为模板约束（constraint）的语言级别支持，解决了长久以来模板编程中“SFINAE”难以阅读、错误信息模糊的问题。下面从概念的定义、使用方式以及实际场景进行阐述，并给出代码示例。

---

1. 概念的基本语法

// 定义一个概念
template<typename T>
concept Incrementable = requires(T x) {
    { ++x } -> std::same_as<T&>;   // ++x 必须返回 T&
    { x++ } -> std::same_as <T>;    // x++ 必须返回 T
};

// 使用概念约束模板参数
template<Incrementable T>
T add_one(T value) {
    return ++value;
}

• requires 子句描述了类型 T 必须满足的表达式。
• -> std::same_as<...> 用于指定表达式的返回类型（可以用其他标准库的概念，如 std::convertible_to 等）。
• Incrementable 可以直接用于 requires 语句或 template 参数。

2. 组合与继承概念

// 组合概念
template<typename T>
concept Integral = std::is_integral_v <T>;

template<typename T>
concept SignedIntegral = Integral <T> && std::is_signed_v<T>;

// 继承概念
template<typename T>
concept Number = std::is_arithmetic_v <T>;

// 使用
template<Number T>
T square(T value) {
    return value * value;
}

3. 通过 requires 关键字做局部约束

template<typename T>
void process(T&& t) requires Incrementable <T> {
    // 仅当 T 满足 Incrementable 时才编译
    ++t;
}

4. 与 SFINAE 的对比

// 传统 SFINAE
template<typename T,
         std::enable_if_t<std::is_integral_v<T>, int> = 0>
T multiply(T a, T b) { return a * b; }

// 现代概念
template<std::integral T>
T multiply(T a, T b) { return a * b; }

概念提供了更直观、错误信息更友好的约束方式。

5. 实际应用场景

场景	传统实现	用概念实现	优点
容器适配	SFINAE 检测 size()、begin() 等	直接约束 std::ranges::range	更清晰的错误信息
数值运算	手写 requires	std::floating_point、std::integral	标准化约束
多态接口	复杂的 enable_if	requires 语句	更易维护

6. 常用标准库概念

标准概念	用途
std::integral	整数类型
std::floating_point	浮点数
`std::same_as
`	两个表达式的类型相同
`std::derived_from
`	子类约束
`std::convertible_to
`	可转换为某类型

7. 实战示例：范围适配器

#include <concepts>
#include <ranges>
#include <vector>
#include <iostream>

template<std::ranges::input_range R>
auto sum(R&& r) {
    using T = std::ranges::range_value_t <R>;
    T total{};
    for (auto&& v : r) total += v;
    return total;
}

int main() {
    std::vector <int> v = {1,2,3,4};
    std::cout << sum(v) << '\n';          // 10
    std::cout << sum(v | std::views::reverse) << '\n'; // 10
}

此函数仅适用于输入范围（input_range），并在编译时得到准确的错误提示。

8. 潜在陷阱与注意事项

1. 递归概念：如果概念彼此递归引用，编译器会报错。避免深层递归。
2. 默认参数：requires 子句中的表达式会被实例化；若涉及到大量类型检查，可能导致编译时间上升。
3. 命名冲突：与标准库同名概念需谨慎；可使用命名空间隔离。

9. 结语

概念使模板编程更像普通函数编程，约束显式、错误信息友好。随着 C++20 的广泛应用，掌握概念将成为提升代码质量与开发效率的关键。希望本文能帮助你快速上手，写出更安全、可读的模板代码。

In C++11 and beyond, parallelism and asynchronous programming became a first‑class citizen of the language. The standard library provides two key abstractions for launching tasks asynchronously: std::async and std::future. These tools simplify the management of background operations, allow you to avoid blocking the main thread, and provide a clean mechanism to retrieve results or propagate exceptions. Below we explore how they work, common pitfalls, and best practices.

1. What is std::async?

std::async launches a function (or a callable object) potentially in a new thread and returns a std::future representing the eventual result. The function signature is:

template <class F, class... Args>
std::future<std::invoke_result_t<F, Args...>>
async(std::launch policy, F&& f, Args&&... args);

The policy parameter controls when the task executes:

• std::launch::async – guarantees a new thread will be started.
• std::launch::deferred – execution is postponed until the future is accessed.
• std::launch::async | std::launch::deferred – default, the implementation decides.

If you omit the policy, the default is the bitwise OR of both options.

2. Retrieving Results with std::future

A `std::future

` can be queried in two ways: – `future.get()` – blocks until the value is ready and returns it (or throws if the task threw an exception). – `future.wait()` or `future.wait_for()` – block only until the result is ready or a timeout occurs, returning a status. Once a `future` has been retrieved (via `get()`), it becomes invalid; calling `get()` again will result in `std::future_error`. ### 3. Example: Parallel Fibonacci “`cpp #include #include #include #include // Expensive recursive Fibonacci int fib(int n) { if (n <= 1) return n; std::this_thread::sleep_for(std::chrono::milliseconds(10)); // simulate work return fib(n-1) + fib(n-2); } int main() { std::future fut1 = std::async(std::launch::async, fib, 20); std::future fut2 = std::async(std::launch::async, fib, 21); std::cout << "Computing Fibonacci in parallel…\n"; int result = fut1.get() + fut2.get(); std::cout << "Result: " << result << '\n'; return 0; } “` In this example, two Fibonacci computations run concurrently, each in its own thread. The main thread blocks on `get()` until both results are ready. ### 4. Deferred Execution When you use `std::launch::deferred`, the task executes only when the future is queried: “`cpp auto deferred = std::async(std::launch::deferred, [](){ return 42; }); std::cout << "Deferred result: " << deferred.get() << '\n'; “` The call to `get()` triggers the function, and no thread is spawned. ### 5. Handling Exceptions If the asynchronous function throws, the exception is stored inside the `future`. When you call `get()`, the exception is rethrown: “`cpp auto fut = std::async([](){ throw std::runtime_error("oops"); }); try { fut.get(); } catch (const std::exception& e) { std::cerr << "Caught: " << e.what() << '\n'; } “` This mechanism enables clean error propagation across thread boundaries. ### 6. Cancellation and Timeouts Unlike some third‑party thread libraries, `std::async` offers no built‑in cancellation. If you need to stop a task prematurely, design the callable to periodically check a shared flag (e.g., `std::atomic `). For timeouts, combine `wait_for` with a cancellation token: “`cpp if (fut.wait_for(std::chrono::seconds(1)) == std::future_status::ready) { std::cout << "Result: " << fut.get() << '\n'; } else { std::cout << "Timed out!\n"; // optionally set cancellation flag } “` ### 7. Common Pitfalls | Pitfall | Explanation | Remedy | |———|————-|——–| | **Forgetting to join** | If the policy is `deferred`, the thread never starts, but if the program ends before `future.get()`, resources might leak. | Always call `get()` or `wait()` before the `future` goes out of scope. | | **Multiple `get()` calls** | After the first `get()`, the `future` is invalid. | Call `get()` only once. | | **Unbounded recursion** | Asynchronous tasks that spawn more async tasks can quickly exhaust system resources. | Limit recursion depth or use thread pools. | | **Deadlocks** | Mixing synchronous and asynchronous code incorrectly can block forever. | Use proper synchronization or redesign the flow. | ### 8. When to Use `std::async` – **Simple, single-task parallelism**: Launch a heavy computation and let the system decide whether to create a thread. – **Library design**: Provide an asynchronous interface to callers while hiding thread management. – **Quick prototyping**: Rapidly convert blocking code to non‑blocking. For more complex scenarios—e.g., many concurrent tasks, fine‑grained scheduling, or thread pools—consider `std::thread` with `std::async`‑style wrappers or third‑party libraries like Intel TBB, Microsoft PPL, or Boost.Asio. ### 9. Conclusion `std::async` and `std::future` give modern C++ programmers a lightweight, type‑safe way to perform asynchronous operations without boilerplate thread management. Understanding launch policies, result retrieval, exception handling, and limitations empowers you to write cleaner, more maintainable concurrent code. As you grow more comfortable, you can layer these primitives into higher‑level abstractions that fit your application's needs.

std::variant 是 C++17 引入的一个强类型联合体（type-safe union），它可以安全地在运行时存储多种不同类型的值。相比传统的 void* 或者自定义联合体，std::variant 提供了更好的类型安全、易用性和可维护性。下面我们将从基本概念、常用成员函数、访问方式以及与 std::visit 的配合使用几个方面来深入了解 std::variant。

1. 基本概念

#include <variant>
#include <iostream>
#include <string>

using namespace std;

int main() {
    variant<int, string, double> v{42};
    cout << v.index() << endl;        // 输出 0，表示当前存储的是第一个类型（int）
    cout << get<int>(v) << endl;      // 输出 42
}

• variant 是一个模板类，接受任意数量的类型参数，表示它可以存储这些类型中的任意一种。
• index() 返回当前存储类型在模板参数列表中的位置（从 0 开始）。如果未存储任何值，则返回 variant_npos（定义在 ` ` 中）。
• `get (v)` 用于获取当前存储的值，如果类型不匹配则抛出 `bad_variant_access`。

2. 常用成员函数

函数	作用
valueless_by_exception()	检查是否因异常导致失效（当构造、赋值过程中抛出异常时会返回 true）
valueless()	与 valueless_by_exception() 等价
index()	返回当前存储类型的索引
`holds_alternative
(v)`	判断当前存储的类型是否为 T
`get
(v)`	取值，若类型不匹配则抛出异常
visit	访问存储值的多态方式（见下文）
`emplace
(args…)`	在指定索引位置构造新值
swap(v1, v2)	交换两个 variant 的值

3. 访问方式

3.1 传统访问

variant<int, string> v = "hello";
if (holds_alternative <string>(v))
    cout << get<string>(v) << endl;

3.2 使用 std::visit

std::visit 结合一个可调用对象（如 lambda 或结构体）对存储的值进行访问，支持模式匹配式写法。

variant<int, string, double> v{3.14};

auto visitor = [](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>)
        std::cout << "int: " << arg << '\n';
    else if constexpr (std::is_same_v<T, double>)
        std::cout << "double: " << arg << '\n';
    else if constexpr (std::is_same_v<T, std::string>)
        std::cout << "string: " << arg << '\n';
};

visit(visitor, v);

这种方式避免了显式检查类型，代码更简洁且类型安全。

4. 与 std::optional 的比较

• std::optional 只能存储单一类型，但允许“无值”状态。
• std::variant 能存储多种类型，但不支持“无值”状态（除非使用 std::monostate 作为一种占位类型）。

如果你需要既有“无值”又有多种类型，可以组合使用：

variant<std::monostate, int, string> v{std::monostate{}};

5. 典型应用场景

5.1 结果与错误的统一返回

#include <variant>
#include <string>

using Result = std::variant<int, std::string>; // int 成功，string 为错误信息

Result do_something(int x) {
    if (x >= 0) return x * 2;
    return std::string("负数不可处理");
}

5.2 事件系统

struct ClickEvent { int x, y; };
struct KeyEvent { char key; };
struct ResizeEvent { int width, height; };

using Event = std::variant<ClickEvent, KeyEvent, ResizeEvent>;

void handle_event(const Event& e) {
    std::visit(overloaded {
        [](const ClickEvent& c){ /* 处理点击 */ },
        [](const KeyEvent& k){ /* 处理键盘 */ },
        [](const ResizeEvent& r){ /* 处理窗口大小改变 */ }
    }, e);
}

6. 性能与实现细节

• variant 的大小等于其内部所有候选类型中最大类型的大小，再加上一个索引字段（通常是 unsigned int 或更小的位域）。因此，如果类型非常大，variant 可能会占用较多内存。
• variant 在构造、复制、移动时会根据索引调用相应类型的构造函数。异常安全保证：如果构造失败，variant 将保持 valueless 状态。

7. 常见陷阱

1. 忘记使用 std::monostate：如果需要表示“空”状态，记得加入 std::monostate。
2. **使用 `get ` 但不检查 `holds_alternative`**：这会导致运行时异常，最好使用 `visit` 或 `get_if`。
3. 不清楚 valueless_by_exception 的意义：如果构造失败，variant 可能变成 valueless，后续访问会抛异常。

8. 小结

std::variant 为 C++ 提供了强类型联合体的实现，使得处理多种可能类型变得安全、清晰。通过 visit 的模式匹配式访问以及与 std::optional 的组合使用，能够满足各种复杂场景。掌握它后，你可以用更少的代码实现更安全、更易维护的逻辑。

在 C++20 中，协程（coroutines）为异步编程提供了极大的便利。与传统的回调或线程模型相比，协程使代码更易读、维护性更好，且性能更优。下面通过一个最小化示例，演示如何在 C++20 中创建、使用以及优化协程，并提供一些常见的陷阱与最佳实践。

---

1. 基础概念回顾

• awaiter：实现 await_ready, await_suspend, await_resume 的对象。
• generator：最常见的协程形态，用于按需生成值。
• task：封装异步操作，通常返回 std::future 或自定义状态。

2. 一个简单的生成器

#include <iostream>
#include <coroutine>
#include <optional>

template <typename T>
struct generator {
    struct promise_type {
        T current_value;
        std::optional <T> value_;

        auto get_return_object() { return generator{std::coroutine_handle <promise_type>::from_promise(*this)}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::exit(1); }

        template <typename U>
        std::suspend_always yield_value(U&& v) {
            current_value = std::forward <U>(v);
            value_ = current_value;
            return {};
        }

        void return_void() {}
    };

    std::coroutine_handle <promise_type> handle_;
    explicit generator(std::coroutine_handle <promise_type> h) : handle_(h) {}
    ~generator() { if (handle_) handle_.destroy(); }

    bool next() {
        if (!handle_.done()) {
            handle_.resume();
            return !handle_.done();
        }
        return false;
    }

    T current() const { return handle_.promise().current_value; }
};

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

使用示例：

int main() {
    auto gen = range(0, 5);
    while (gen.next())
        std::cout << gen.current() << " ";
}

输出：0 1 2 3 4

3. 协程与 std::future

虽然协程可以直接返回值，但在现代 C++ 中，最常见的做法是将协程包装成 std::future，实现异步任务。下面给出一个 async_task 的简易实现：

#include <future>
#include <coroutine>

template <typename T>
struct async_task {
    struct promise_type {
        T result_;
        std::exception_ptr eptr_;

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

        void unhandled_exception() { eptr_ = std::current_exception(); }
        void return_value(T value) { result_ = std::move(value); }

        std::future <T> get_future() {
            return std::future <T>(handle_);
        }
    };

    std::coroutine_handle <promise_type> handle_;
    explicit async_task(std::coroutine_handle <promise_type> h) : handle_(h) {}
    ~async_task() { if (handle_) handle_.destroy(); }

    std::future <T> get_future() { return handle_.promise().get_future(); }
};

使用：

async_task <int> async_add(int a, int b) {
    co_return a + b;
}

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

4. 性能与资源管理

4.1 关闭不必要的挂起

协程的默认 suspend_always 会在每次 co_yield 或 co_return 时挂起。若不需要暂停，可使用 suspend_never，从而避免一次无意义的上下文切换：

std::suspend_never initial_suspend() { return {}; }  // 立即开始执行

4.2 std::shared_future 与 task

如果多个消费者需要同一个协程结果，使用 std::shared_future 可避免重复执行：

auto fut = std::shared_future <int>(task.get_future());

4.3 错误传播

协程内部抛出的异常会被 unhandled_exception 捕获并保存为 exception_ptr。用户可以在 future::get() 时重新抛出，保持错误信息完整。

5. 常见陷阱

1. 忘记销毁协程句柄：协程句柄必须在不再使用时 destroy()，否则会导致内存泄漏。
2. 过度使用 co_yield：如果每次 co_yield 都需要一次上下文切换，性能会下降。可考虑将值一次性生成或使用批处理。
3. 不兼容的返回类型：co_return 必须匹配 promise_type::return_value 的签名，否则编译失败。

6. 进一步阅读

• 《C++ Coroutines》作者: Herb Sutter, Niall Douglas
• cppreference.com: std::generator, std::future, std::coroutine_handle

---

小结

C++20 协程通过让编译器处理挂起与恢复细节，极大简化了异步代码的写法。掌握协程的基础结构（promise、awaiter、handle），并结合 std::future 与资源管理模式，能够让你在需要高并发、低延迟的场景下写出既高效又易读的代码。祝你在 C++ 的协程旅程中愉快前行!

在 C++20 之后，标准库引入了 ranges 子系统，它提供了一套基于管道式语法的算法和适配器，极大地简化了集合操作的代码。本文以一段常见的数据处理任务为例，演示如何使用 ranges 来实现更加简洁、可读性更强的代码。

---

1. 背景与目标

假设我们有一份销售数据，每条记录包含商品编号、销量和价格。我们需要：

1. 过滤掉销量低于 50 的商品；
2. 计算剩余商品的总收入（销量 × 价格）；
3. 按降序输出收入最高的前 5 条记录。

传统方式需要使用 std::copy_if、std::transform、std::accumulate 等组合，代码量较大；而 ranges 可以一次性完成所有步骤。

---

2. 示例数据结构

#include <vector>
#include <string>

struct Sale {
    std::string sku;
    int        quantity;
    double     price;
};

我们假设 `std::vector

sales` 已经填充好了。 — ### 3. 使用 `ranges` 的实现 “`cpp #include #include #include #include #include namespace rv = std::ranges; namespace vw = std::views; int main() { std::vector sales = /* … 填充数据 … */; // 1. 过滤销量 >= 50 的记录 auto filtered = sales | vw::filter([](auto const& s){ return s.quantity >= 50; }); // 2. 计算每条记录的收入 auto revenue = filtered | vw::transform([](auto const& s){ return s.quantity * s.price; }); // 3. 计算总收入 double total_revenue = rv::accumulate(revenue, 0.0); // 4. 取前 5 条收入最高的记录（按降序） auto top5 = filtered | vw::transform([](auto const& s){ return std::make_pair(s, s.quantity * s.price); }) | vw::partial_sort(vw::begin, vw::end, 5, [](auto const& a, auto const& b){ return a.second > b.second; }); // 输出结果 std::cout << std::fixed << std::setprecision(2); std::cout << "总收入: $" << total_revenue << "\n"; std::cout << "前 5 高收入记录:\n"; for (auto const& [s, rev] : top5) { std::cout << s.sku << " | 销量: " << s.quantity << " | 价格: $" << s.price << " | 收入: $" << rev < 以上数据基于 x86_64 + GCC 12.1，编译选项 `-O3 -march=native`。 — ### 5. 结语 C++20 的 `ranges` 子系统提供了一种优雅、类型安全且高效的集合处理方式。熟练掌握其视图与适配器，能够让你在保持性能的同时，大幅提升代码可读性与维护性。下次再面对数据过滤、映射、聚合等任务时，不妨尝试用 `ranges` 写一遍，感受一下它带来的 “一眼看懂” 体验。