standrad c++

在C++20之前，模板编程常常伴随着大量的SFINAE技巧和静态断言，使得错误信息难以理解，甚至在编译时会产生无关的警告。C++20引入的概念（Concepts）正是为了解决这些问题而设计的。本文将介绍概念的基本语法、常用概念、以及如何在实际项目中逐步替换SFINAE，从而提升代码的可读性与可维护性。

1. 概念是什么？

概念是一种模板参数的约束，用来描述某个类型需要满足的一组“属性”。它们类似于接口，却可以在编译时被静态检查。使用概念后，编译器在报错时会直接给出“类型不满足某个概念”的提示，而不是一堆模糊的SFINAE错误。

2. 基本语法

#include <concepts>
#include <iostream>
#include <vector>
#include <list>

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

template <Incrementable T>
void incrementAll(std::vector <T>& vec) {
    for (auto& v : vec) ++v;
}

上例中，Incrementable 定义了一个概念，要求传入类型 T 必须支持前置递增和后置递增。随后在 incrementAll 的模板参数中直接写 Incrementable T，编译器会自动检查 T 是否满足该概念。

3. 常用标准概念

C++20 提供了一系列在 `

` 头文件中定义的概念，涵盖了算术类型、迭代器、可比较性等： | 概念 | 说明 | |——|——| | `std::integral` | 整数类型 | | `std::floating_point` | 浮点数类型 | | `std::ranges::input_iterator` | 输入迭代器 | | `std::equality_comparable` | 支持 `==` 和 `!=` | | `std::sortable` | 可用于排序的类型（C++23 起） | 使用示例： “`cpp #include #include #include template T sum(std::vector const& v) { return std::accumulate(v.begin(), v.end(), static_cast (0)); } “` ### 4. 如何替换旧的 SFINAE 技巧？ #### 4.1 传统 SFINAE “`cpp template <typename t typename="std::enable_if_t<std::is_integral_v>> T square(T value) { return value * value; } “` #### 4.2 现代概念 “`cpp #include template T square(T value) { return value * value; } “` 概念版更简洁，也更易读。编译器在报错时会直接指出“T 必须是整数类型”，而不是出现“模板参数不匹配”的长串错误。 #### 4.3 复合概念 当需要多个条件时，可以组合概念： “`cpp template concept IncrementableNumeric = std::integral || std::floating_point; template T addOne(T v) { return v + 1; } “` ### 5. 进阶用法：自定义概念与约束 假设我们有一个容器类，需要保证元素类型支持比较操作。可以写： “`cpp template concept Comparable = requires(T a, T b) { { a std::convertible_to; { a == b } -> std::convertible_to ; }; template class SortedList { std::vector data; public: void insert(const T& value) { auto it = std::lower_bound(data.begin(), data.end(), value); data.insert(it, value); } }; “` ### 6. 在大型项目中逐步迁移 1. **从 SFINAE 过渡**：在已有函数或类中，先为关键模板参数添加概念约束。 2. **提供替代实现**：如果某个类型不满足概念，可在 `requires` 子句中提供替代实现。 3. **文档化**：将概念作为接口文档的一部分，让使用者一目了然。 4. **单元测试**：确保在迁移过程中不破坏现有行为。 ### 7. 结论 概念让模板编程更安全、更易维护。它们通过在编译期显式约束模板参数，使错误信息更加直观，也减少了模板错误导致的编译时间。虽然 C++20 的概念并非万能，但在大多数需要模板约束的场景下，它们已足以替代繁琐的 SFINAE 技巧。欢迎在自己的项目中尝试使用概念，并逐步升级已有代码，享受更清晰、可读性更高的模板编程体验。

协程（Coroutines）在 C++20 标准中正式加入标准库，为异步编程提供了强大而简洁的工具。虽然在 C++17 里没有直接支持协程的语法，但通过第三方库（如 Boost.Coroutine 或 cppcoro）以及手写状态机，仍能在 C++17 环境下模拟协程的行为。下面我们通过一个简易的生成器实现，演示如何在 C++17 中用类和迭代器模式实现协程效果。

#include <iostream>
#include <functional>
#include <vector>

template <typename T>
class Generator {
public:
    using GeneratorFunc = std::function<void(std::function<void(const T&)>)>;

    explicit Generator(GeneratorFunc func) : genFunc(std::move(func)) {}

    // 内部迭代器，用于遍历生成器产出的值
    class Iterator {
    public:
        Iterator(Generator* parent, bool end = false) : parent(parent), finished(end) {
            if (!finished) {
                // 立即请求第一个值
                parent->nextValue(*this);
            }
        }

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

        Iterator& operator++() {
            parent->nextValue(*this);
            return *this;
        }

        bool operator==(const Iterator& other) const { return finished == other.finished; }
        bool operator!=(const Iterator& other) const { return !(*this == other); }

    private:
        friend class Generator;
        Generator* parent;
        T value;
        bool finished = false;

        // 生成器从内部调用此方法获取下一个值
        void setValue(const T& val) { value = val; finished = false; }
    };

    Iterator begin() { return Iterator(this); }
    Iterator end()   { return Iterator(this, true); }

private:
    GeneratorFunc genFunc;
    std::vector <T> buffer;  // 缓存最近生成的值，支持多次遍历
    size_t bufferIndex = 0;

    void nextValue(Iterator& it) {
        if (bufferIndex < buffer.size()) {
            it.setValue(buffer[bufferIndex++]);
        } else {
            // 通过回调模式生成下一个值
            bool produced = false;
            genFunc([&](const T& val) {
                buffer.push_back(val);
                it.setValue(val);
                produced = true;
            });
            if (!produced) {
                it.finished = true;
            } else {
                bufferIndex = 1;
            }
        }
    }
};

// 使用示例：生成斐波那契数列的前10项
int main() {
    Generator <int> fib([](std::function<void(const int&)> yield) {
        int a = 0, b = 1;
        for (int i = 0; i < 10; ++i) {
            yield(a);
            int tmp = a + b;
            a = b;
            b = tmp;
        }
    });

    std::cout << "斐波那契数列前10项:\n";
    for (int n : fib) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
    return 0;
}

代码要点说明

1. Generator 类

   • 接收一个函数 GeneratorFunc，该函数内部使用 yield 回调把生成的值“投递”给外部。
   • begin() 与 end() 方法返回自定义迭代器，满足 C++ 的范围 for 循环。

2. Iterator 内部状态

   • finished 用来标记是否已生成完所有值。
   • setValue 供内部 nextValue 调用来更新迭代器值。

3. 缓冲区 buffer

   • 用来缓存已生成的值，支持多次遍历。
   • bufferIndex 跟踪当前读取位置。

4. 协程模拟

   • 通过回调 yield，在生成函数中暂停并返回下一个值，类似协程的 yield。
   • 生成函数在需要停止时不调用 yield，导致 produced 为 false，从而终止迭代。

进一步扩展

• 异步读取：可以在 GeneratorFunc 内部使用 std::future 或 std::async，在协程停顿时进行 IO 操作。
• 多种数据类型：`Generator ` 可被任何可拷贝或移动类型使用，满足不同业务需求。
• 错误处理：在 yield 里传递异常或错误码，以便外层捕获。

尽管 C++17 本身不支持 co_await、co_yield 等语法，但通过上述模式仍能在较老的编译器中实现协程般的行为。随着 C++20 的普及，建议在新项目中直接使用原生协程语法，以获得更直观、性能更优的实现。

在 C++17 之后，std::variant 与 std::optional 成为标准库中非常实用的类型，用来替代传统的裸指针或手动管理内存的方式。本文将通过一个具体的业务场景——实现一个简单的表单数据校验器，演示如何利用这两个类型提升代码安全性、可读性和维护性。

1. 背景：表单数据的多态结构

假设我们正在开发一个多租户系统，每个租户的表单字段类型各不相同：

• 有的字段为字符串（如“用户名”）
• 有的字段为整数（如“年龄”）
• 有的字段可选（如“备注”）
• 有的字段是枚举（如“性别”）

传统做法常用 void* 或 boost::variant，需要显式检查类型并转换，容易出错。C++17 的 std::variant 可以直接把所有可能的类型打包在一个容器里，std::optional 则能自然表示“可选”字段。

2. 设计数据结构

#include <variant>
#include <optional>
#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>

// 枚举类型
enum class Gender { Male, Female, Other };

// 表单字段的值类型
using FieldValue = std::variant<
    std::string,          // 文本
    int,                  // 整数
    double,               // 浮点
    bool,                 // 布尔
    Gender,               // 枚举
    std::optional<std::string> // 可选文本
>;

// 表单字段描述
struct FieldDef {
    std::string name;
    bool required;
};

// 表单数据
using FormData = std::unordered_map<std::string, FieldValue>;
using FormDefs = std::vector <FieldDef>;

3. 解析与验证流程

3.1 解析

我们从 JSON（这里只用字符串演示）解析成 FormData。在解析过程中，根据字段名称判断应该存入哪种类型。

FieldValue parseField(const std::string& key, const std::string& value) {
    if (key == "age") {
        return std::stoi(value);
    } else if (key == "salary") {
        return std::stod(value);
    } else if (key == "gender") {
        if (value == "male") return Gender::Male;
        if (value == "female") return Gender::Female;
        return Gender::Other;
    } else if (key == "active") {
        return value == "true";
    } else {
        return value; // 默认文本
    }
}

3.2 验证

使用 std::variant 的 `std::holds_alternative

` 或 `std::visit` 进行类型检查，配合 `std::optional` 判断必填字段是否存在。 “`cpp bool validate(const FormDefs& defs, const FormData& data) { for (const auto& def : defs) { auto it = data.find(def.name); if (def.required && it == data.end()) { std::cerr (it->second)) { std::cerr (“首席研发”) } // 可选字段 }; // 3. 验证 if (validate(defs, data)) { std::cout ; if constexpr (std::is_same_v) std::cout ) std::cout ) std::cout ) std::cout ) { if (arg == Gender::Male) std::cout >) { if (arg) std::cout

在现代 C++（C++17 及以后）中，std::variant 为我们提供了一种简单且类型安全的方式来存储多种类型的值。它可以用来实现一个事件系统，其中每种事件都有自己的数据结构，而不必依赖传统的继承与虚函数。本文将演示如何利用 std::variant、std::visit 和自定义事件类型来构建一个轻量级、可扩展的事件系统。

1. 设计事件类型

首先，定义几种不同的事件结构。每种事件都有自己的属性，以满足业务需求。

struct MouseEvent {
    int x;
    int y;
    int button; // 0: left, 1: right
};

struct KeyboardEvent {
    char key;
    bool ctrl;
    bool shift;
};

struct TimerEvent {
    std::chrono::steady_clock::time_point timestamp;
};

2. 定义事件别名

利用 std::variant 将所有事件类型组合在一起：

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

此时，Event 就可以容纳任意一种事件类型，并保持类型安全。

3. 事件回调类型

我们需要一个统一的回调类型来处理所有事件。使用 std::function<void(const Event&)> 作为事件处理器：

using EventHandler = std::function<void(const Event&)>;

4. 事件总线

实现一个简单的事件总线，用于注册、触发事件。

class EventBus {
public:
    // 注册回调
    void subscribe(const EventHandler& handler) {
        handlers_.push_back(handler);
    }

    // 触发事件
    void publish(const Event& event) const {
        for (const auto& h : handlers_) {
            h(event);
        }
    }

private:
    std::vector <EventHandler> handlers_;
};

5. 处理事件的示例

下面演示如何使用 std::visit 来根据事件类型执行不同的逻辑。

void handleEvent(const Event& e) {
    std::visit([](auto&& arg){
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, MouseEvent>) {
            std::cout << "Mouse at (" << arg.x << ", " << arg.y << ") button " << arg.button << '\n';
        } else if constexpr (std::is_same_v<T, KeyboardEvent>) {
            std::cout << "Key '" << arg.key << "' ctrl=" << arg.ctrl << " shift=" << arg.shift << '\n';
        } else if constexpr (std::is_same_v<T, TimerEvent>) {
            std::cout << "Timer event at " << std::chrono::duration_cast<std::chrono::milliseconds>(arg.timestamp.time_since_epoch()).count() << " ms\n";
        }
    }, e);
}

6. 使用完整示例

int main() {
    EventBus bus;
    bus.subscribe(handleEvent);

    // 产生鼠标事件
    MouseEvent me{100, 200, 0};
    bus.publish(me);

    // 产生键盘事件
    KeyboardEvent ke{'A', true, false};
    bus.publish(ke);

    // 产生计时器事件
    TimerEvent te{std::chrono::steady_clock::now()};
    bus.publish(te);

    return 0;
}

7. 优点与适用场景

• 类型安全：std::variant 在编译期检查类型，避免了运行时的错误。
• 零运行时开销：与传统多态相比，std::variant 只需要存储一个固定大小的联合体，避免了虚函数表的间接寻址。
• 可扩展性：只需在 Event 列表中添加新的事件类型即可，无需修改已有回调代码。
• 适用于事件驱动系统：如 GUI 事件、网络协议事件、游戏引擎内部事件等。

8. 小结

通过 std::variant 与 std::visit，我们可以在 C++17 及以后版本中轻松实现一个高效、类型安全的事件系统。相比传统的继承+虚函数方法，这种方式更简洁、性能更好，且易于维护。希望本示例能为你在项目中使用 std::variant 处理多类型事件提供帮助。

C++20 引入了协程（coroutine）概念，极大地方便了异步编程。借助协程，我们可以像同步代码一样书写异步逻辑，同时实现无阻塞 IO 的效果。本文将从理论与实践两方面介绍如何用 C++20 协程构建一个简易的无阻塞 IO 框架，并指出常见坑点和最佳实践。

1. 协程基础

在 C++20 里，协程的核心是四个关键字：co_await、co_yield、co_return 和 co_suspend。协程函数返回一个可挂起的类型（通常是 std::future、std::generator 或自定义的 Awaitable）。编译器会把协程函数展开为一个状态机，挂起点会保存局部状态，恢复点会继续执行。

1.1 Awaitable 的实现

一个类型需要实现 await_ready、await_suspend 和 await_resume 三个成员函数，才能被 co_await 调用。最常见的例子是 std::future，它的 await_resume 会返回值。

struct AsyncSocket {
    int fd;  // 文件描述符
    std::function<void()> ready_cb;  // 就绪回调

    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        // 这里把回调注册到事件循环，完成后恢复协程
        register_read_event(fd, [h]() { h.resume(); });
    }
    void await_resume() const noexcept { /* 返回读取结果 */ }
};

2. 事件循环的最小实现

协程本身不提供事件循环，需要我们自己实现。最简单的方式是基于 epoll（Linux）或 kqueue（BSD/macOS）构建事件循环。下面给出一个极简的 EventLoop 类：

class EventLoop {
    int epfd = epoll_create1(0);
    std::unordered_map<int, std::function<void()>> callbacks;

public:
    ~EventLoop() { close(epfd); }

    void add_read(int fd, std::function<void()> cb) {
        epoll_event ev{ .events = EPOLLIN, .data.fd = fd };
        epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
        callbacks[fd] = std::move(cb);
    }

    void run() {
        epoll_event events[64];
        while (true) {
            int n = epoll_wait(epfd, events, 64, -1);
            for (int i = 0; i < n; ++i) {
                int fd = events[i].data.fd;
                auto it = callbacks.find(fd);
                if (it != callbacks.end()) it->second();
            }
        }
    }
};

3. 简易无阻塞 HTTP 客户端

下面演示如何用协程和事件循环写一个不阻塞的 HTTP GET 请求。

#include <coroutine>
#include <future>
#include <iostream>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

class EventLoop {
    /* 见上文实现 */
};

EventLoop loop;

int make_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    return 0;
}

struct AwaitableRead {
    int fd;
    std::vector <char> buffer;
    size_t pos = 0;

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) {
        loop.add_read(fd, [h]() mutable { h.resume(); });
    }

    std::vector <char> await_resume() {
        // 简化：假设一次读取完成
        return buffer;
    }
};

awaitable_read read_fd(int fd) {
    AwaitableRead ar{fd};
    // 读取一次
    char tmp[4096];
    ssize_t n = read(fd, tmp, sizeof(tmp));
    if (n > 0) ar.buffer.insert(ar.buffer.end(), tmp, tmp + n);
    co_return ar.buffer;
}

awaitable_co void http_get(const std::string& host, const std::string& path) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    make_nonblocking(sock);
    /* 连接到 host:80 ... */
    // 省略连接代码，假设已连接

    std::string req = "GET " + path + " HTTP/1.1\r\n"
                      "Host: " + host + "\r\n"
                      "Connection: close\r\n\r\n";
    send(sock, req.c_str(), req.size(), 0);

    // 等待可读
    std::vector <char> resp = co_await read_fd(sock);

    std::cout << "Received " << resp.size() << " bytes\n";
    close(sock);
}

int main() {
    http_get("example.com", "/").resume();  // 启动协程
    loop.run();                             // 开始事件循环
}

注意：上述代码极度简化，仅演示协程挂起与恢复的机制。实际生产代码需要处理错误、完整性读取、时间戳、心跳等。

4. 常见坑点

1. 忘记把文件描述符设置为非阻塞：如果不设置，read/write 仍会阻塞，导致协程挂起失效。
2. 回调持有错误的协程句柄：await_suspend 必须在回调中保存协程句柄，并在 IO 完成后恢复。
3. 事件循环与协程的交互：在事件循环中恢复协程后，若协程再次挂起，需要重新注册事件。
4. 资源泄漏：事件循环退出前要确保关闭所有文件描述符、取消注册。

5. 小结

C++20 协程为无阻塞 IO 提供了极佳的语言层支持。通过自定义 Awaitable、实现简易事件循环，我们可以在保持同步风格的同时实现高并发的异步网络程序。实际使用中，建议借助成熟的库（如 asio、libuv）或使用 std::experimental::awaitable 之类的高级抽象，避免从零开始实现复杂细节。

祝你编码愉快，玩转协程世界！

C++20 引入了模块（Modules）这一重要特性，旨在解决传统头文件（#include）带来的编译速度慢、命名冲突多等问题。下面将从模块的基本概念、实现机制、使用方法以及实际应用场景进行系统讲解，并给出完整的代码示例。

---

1. 模块的基本概念

关键词	含义
导出 (export)	将模块内的声明、定义暴露给其他模块使用。
模块单元 (module)	一个源文件或一组源文件组成的模块单元，具有独立的编译单元。
模块接口单元	模块的公共接口，包含需要导出的内容。
模块实现单元	模块的私有实现，包含内部使用的代码。
模块片段 (#module 或 #pragma)	在同一文件中混合接口与实现时使用。

与传统的头文件不同，模块将编译单元划分为“接口”和“实现”，在编译时只需要一次解析接口，后续编译只需引用已编译的模块接口（*.ifc 或 *.ixx）。

---

2. 模块的实现机制

1. 编译单元分离

   • 模块接口单元（.ixx）会生成模块界面文件（*.ifc）。
   • 模块实现单元（.cpp）只编译一次，引用接口单元时直接使用已生成的 .ifc。

2. 导入与使用

   import MyMath;          // 导入模块 MyMath

   • 该语句会在编译时链接对应的模块界面文件，而不需要在每个使用点进行 #include。

3. 依赖关系

   • 模块可以依赖其他模块：import std.core;
   • 编译顺序：先编译被依赖模块，再编译依赖模块。

4. 预编译模块

   • 通过 -fprebuilt-module-path 指定已编译好的模块目录，加速编译。

---

3. 使用方法

3.1 创建一个简单模块

模块接口单元（Math.ixx）

#pragma once
export module Math;   // 声明模块名称为 Math

export int add(int a, int b) {
    return a + b;
}

export int multiply(int a, int b) {
    return a * b;
}

模块实现单元（Math.cpp）

module Math; // 同名模块，表示实现单元

// 可以包含私有实现、测试代码等

3.2 使用模块

主程序（main.cpp）

import Math;  // 导入 Math 模块
import std.core;

int main() {
    int sum = add(3, 4);          // 调用模块中的函数
    int prod = multiply(5, 6);

    std::cout << "sum: " << sum << ", prod: " << prod << '\n';
    return 0;
}

3.3 编译命令

使用 g++（>=10）或 clang++（>=13）：

# 编译模块接口
g++ -std=c++20 -fmodule-header Math.ixx -c -o Math.ifc

# 编译实现单元（可选，因为接口单元已包含实现）
g++ -std=c++20 -c Math.cpp -o Math.o

# 编译主程序，指明模块路径
g++ -std=c++20 -fmodules-ts main.cpp Math.ifc Math.o -o app

现代编译器会自动管理模块编译顺序，只需要：

g++ -std=c++20 -fmodules-ts -o app Math.ixx Math.cpp main.cpp

---

4. 实际应用场景

场景	传统头文件的问题	模块的优势
大型项目	头文件多导致编译慢、重复编译	只编译一次接口，引用时快速
第三方库	需要导出大量接口	可将库拆分为多个模块，精细控制可见性
代码安全	#include 导致全局符号泄露	模块支持私有导出，避免全局污染
CI/CD	编译时间长，构建不稳定	模块化编译加速，构建更稳定

---

5. 常见坑与调试技巧

常见问题	解决方案
1. module not found	确认模块路径已加入编译器搜索目录（-fmodule-map-file 或 -fmodule-path）。
2. duplicate symbol	模块内部定义多次时，确保使用 export 或 module 关键词分隔接口与实现。
3. 编译错误指向 import 语句	可能是模块没有正确编译，检查模块生成文件是否存在。
4. 兼容性问题	某些编译器仍在实现标准，使用 -fmodules-ts 进行测试。

---

6. 小结

C++20 模块为 C++ 提供了一套更高效、更安全的编译单元管理机制。通过将代码拆分为模块接口与实现，编译器能够显著减少重复编译，提升大型项目的构建速度。同时，模块的可见性控制也使得代码更易维护。虽然仍有一定的学习曲线，但随着编译器对模块支持的成熟，未来的 C++ 开发将更倾向于使用模块化结构。

推荐阅读：

• 《C++20 Modules》 – 官方文档
• 《Effective Modern C++》作者 Scott Meyers 的模块实现经验

祝你在 C++ 模块化开发中玩得愉快！

在 C++20 之前，处理序列的方式通常是手写循环、使用 STL 算法配合迭代器、或利用 lambda 表达式来实现过滤、转换等操作。C++20 引入了 Ranges（范围）库，为我们提供了更直观、更安全、更强大的序列处理工具。本文将从概念、语法、实例三个维度，帮助你快速掌握并应用 Ranges。

1. 什么是 Ranges？

Ranges 不是一个新算法，而是一套围绕范围（Range）概念的工具。范围相当于一个有起点与终点的序列，可以是容器、迭代器、或自定义生成器。Rangess 通过组合 View（视图）与 Pipe（管道）实现对范围的惰性变换。

• View：对原始范围的无副作用、惰性的包装。例如 std::views::filter、std::views::transform。
• Pipe：通过 | 运算符串联多个 View，形成链式调用。

与传统算法的“迭代器-算法”组合相比，Ranges 让代码更具声明性，意图更明确。

2. 基础语法

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

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

    // 过滤偶数，然后平方
    auto result = v | std::views::filter([](int x){ return x % 2 == 0; })
                    | std::views::transform([](int x){ return x * x; });

    for (int x : result) std::cout << x << ' ';
    std::cout << '\n';
}

关键点

• std::views::filter 接收一个谓词，返回满足条件的子范围。
• std::views::transform 接收一个函数，返回转换后的子范围。
• result 本身不存储数据，而是惰性评估；当 for 循环遍历时才真正执行。

3. 进阶示例：链式管道与自定义 View

3.1 组合多重操作

auto processed = v | std::views::filter([](int x){ return x > 3; })
                   | std::views::transform([](int x){ return x * 10; })
                   | std::views::take(5);

• std::views::take 只保留前 5 个元素。
• 所有 View 都是惰性执行，只有在需要结果时才会一次性遍历一次。

3.2 自定义 View

struct square_view {
    auto begin(auto&& rng) const {
        return std::ranges::begin(rng);
    }
    auto end(auto&& rng) const {
        return std::ranges::end(rng);
    }

    struct iterator {
        std::ranges::iterator_t<decltype(std::declval<auto&&>())> it;
        auto operator*() const { return (*it) * (*it); }
        iterator& operator++() { ++it; return *this; }
        bool operator==(const iterator& other) const { return it == other.it; }
    };
};

auto sq = v | square_view{};

通过自定义 iterator，我们实现了一个完整的 View，使得任何范围都能被平方。

4. 性能与兼容性

• 惰性求值：只有在遍历时才会真正计算，避免不必要的中间结果。
• 内联优化：现代编译器对 Ranges 的内联非常友好，往往可以消除额外的函数调用。
• C++20 兼容：需要 C++20 标准，使用 -std=c++20 编译。

5. 实战场景

1. 数据清洗：读取文件行后过滤空行、转换为数字并做统计。
2. 并行计算：std::views::transform 与 std::execution::par 搭配，实现并行映射。
3. 管道式编程：把复杂业务流程拆成一系列 View，形成清晰的“数据流”图。

6. 小结

C++20 Ranges 通过 View 与 Pipe 的组合，提供了更简洁、可组合、惰性求值的序列处理方式。掌握基本的 filter、transform、take 等 View，并了解如何自定义 View，你就能在项目中显著提升代码可读性和维护性。

赶快尝试把 Ranges 引入你现有的项目，体验“声明式”编程的乐趣吧！

在传统的头文件机制中，编译器需要多次扫描同一个头文件，导致重复编译、宏污染以及二义性错误。C++20 引入的模块（modules）彻底解决了这些痛点，使得构建速度提升显著，同时也提升了代码可维护性。

1. 模块的基本概念

模块由两部分组成：

• 模块接口（Module Interface）：使用 `export module ;` 声明，定义对外暴露的符号。
• 模块实现（Module Implementation）：使用 `module ;` 或不带 `export` 的源文件，包含实现细节。

模块接口文件只编译一次，编译生成的二进制中包含所有导出的符号，其他翻译单元只需 import 该模块。

2. 与头文件的区别

特性	传统头文件	模块
编译时间	可能多次编译同一头文件	只编译一次，生成二进制
作用域	全局宏与名字污染	仅导出的符号可见
依赖关系	隐式且难以跟踪	明确的 import 语句
编译错误	位置难以定位	更精准的错误定位

3. 如何使用模块

3.1 创建模块接口

// mymath.ixx
export module mymath;

export int add(int a, int b) {
    return a + b;
}

export namespace detail {
    inline int sub(int a, int b) { return a - b; }
}

3.2 导入模块

// main.cpp
import mymath;
import <iostream>;

int main() {
    std::cout << "3 + 4 = " << add(3,4) << std::endl;
    // std::cout << detail::sub(5,2); // error: detail not exported
}

3.3 编译方式

# 使用 GCC 11+
g++ -std=c++20 -fmodules-ts -c mymath.ixx -o mymath.o
g++ -std=c++20 -fmodules-ts main.cpp mymath.o -o main

4. 构建效率提升

假设有 1000 个源文件都包含同一个大型头文件 boost.hpp。传统编译会让每个源文件都重新解析该头文件，导致大量重复工作。使用模块后，只需编译一次 boost 模块，后续所有源文件直接 import，构建时间缩短 50%~70%。

5. 可维护性提升

• 明晰依赖：import 语句一目了然，编译器可以更好地进行依赖分析。
• 避免宏冲突：模块内部的宏不影响外部，减少了宏污染。
• 封装实现：模块可以仅导出必要接口，隐藏实现细节。

6. 潜在挑战

• 工具链支持：并非所有 IDE 或构建系统都完全支持模块，需要额外配置。
• 代码迁移成本：将现有项目迁移到模块需要逐步重构。
• 调试体验：在模块化代码中，符号调试可能需要更细致的映射信息。

7. 结语

C++20 模块是一次重构编译模型的机会，既能显著提升编译效率，又能让代码结构更清晰、更易维护。虽然迁移成本不可忽视，但对于大型项目来说，长远收益更具吸引力。建议从核心库开始逐步引入模块，形成模块化生态，再逐步推广到整个代码基。

C++20 新增的协程（coroutine）特性，为异步编程提供了更简洁、更高效的语法。相比传统的回调或 promise‑future 方式，协程以同步的写法实现非阻塞逻辑，极大提升代码可读性。本文将从协程的基本概念、关键字使用，到实际案例——实现一个异步数据流消费，逐步带你掌握协程的核心。

一、协程的基本概念

协程是“可以暂停和恢复执行的函数”。在 C++ 中，协程由 co_await、co_yield、co_return 三个关键字实现，并且需要一个 协程返回类型（如 std::future、std::generator 或自定义类型）。协程在执行到 co_await 时会挂起，等待外部事件完成后恢复执行；co_yield 用于生成值流，调用方通过迭代获取每个生成值。

二、关键字解析

关键字	用途	说明
co_await	暂停协程等待某个可等待对象完成	只适用于返回类型为 std::future、std::task 等
co_yield	产生一个值，暂停协程	常用于实现生成器（generator）
co_return	结束协程并返回结果	生成最终返回值或结束信号

三、协程返回类型

C++20 并未提供统一的协程返回类型，而是留给实现者自定义。最常见的两种：

1. **`std::future `**：标准库提供的异步结果容器。协程可以返回 `std::future`，调用方通过 `get()` 获取结果。
2. **`std::generator `**（或自定义 `generator`）：用于生成值流，类似 Python 的 `yield`。

备注：std::generator 在标准库中并未直接定义，但在很多实现（如 libstdc++、libc++）中可用。若不想依赖实现，可自定义一个简单的生成器。

四、实战示例：异步文件读取 + 数据流消费

下面演示一个完整的协程应用：读取一个文本文件，逐行解析后生成关键字列表，并异步处理每个关键字。

1. 工具类：异步文件读取

#include <fstream>
#include <string>
#include <future>

struct async_file_reader {
    std::ifstream in;
    async_file_reader(const std::string& path) : in(path) {}
    // 返回一个 future，表示一次读取行操作
    std::future<std::string> read_line() {
        return std::async(std::launch::async, [this] {
            std::string line;
            if (std::getline(in, line))
                return line;
            else
                return std::string(); // 空串表示 EOF
        });
    }
};

2. 协程生成器：逐行读取

#include <coroutine>
#include <exception>

template<typename T>
struct generator {
    struct promise_type;
    using handle_type = std::coroutine_handle <promise_type>;

    struct promise_type {
        T current_value;
        std::exception_ptr exc;

        generator get_return_object() {
            return generator{handle_type::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(T value) {
            current_value = value;
            return {};
        }
        void return_void() {}
        void unhandled_exception() { exc = std::current_exception(); }
    };

    handle_type coro;
    generator(handle_type h) : coro(h) {}
    ~generator() { if (coro) coro.destroy(); }
    generator(const generator&) = delete;
    generator& operator=(const generator&) = delete;
    generator(generator&& other) noexcept : coro(other.coro) { other.coro = nullptr; }
    generator& operator=(generator&& other) noexcept {
        if (this != &other) {
            if (coro) coro.destroy();
            coro = other.coro;
            other.coro = nullptr;
        }
        return *this;
    }

    class iterator {
        handle_type coro;
    public:
        explicit iterator(handle_type h) : coro(h) {
            if (coro) coro.resume();
        }
        iterator& operator++() {
            coro.resume();
            return *this;
        }
        const T& operator*() const { return coro.promise().current_value; }
        const T* operator->() const { return &coro.promise().current_value; }
        bool operator==(std::default_sentinel_t) const { return !coro || coro.done(); }
    };

    iterator begin() { return iterator{coro}; }
    std::default_sentinel_t end() { return {}; }
};

3. 协程实现：读取并生成关键字

generator<std::string> line_generator(const std::string& path) {
    async_file_reader reader(path);
    while (true) {
        auto fut = reader.read_line();
        std::string line = fut.get(); // 这里为了示例同步等待，可改为 co_await
        if (line.empty()) break;
        co_yield line; // 暂停协程并返回当前行
    }
}

注意：在真实异步场景中，应使用 co_await fut 而非 fut.get()，以避免阻塞线程。

4. 消费器：并行处理关键字

void process_keywords(const std::string& file_path) {
    for (auto&& line : line_generator(file_path)) {
        // 简单示例：将每行拆分为单词
        std::istringstream iss(line);
        std::string word;
        while (iss >> word) {
            // 这里模拟异步处理（例如网络请求）
            std::async(std::launch::async, [word] {
                std::cout << "Processing keyword: " << word << std::endl;
            });
        }
    }
}

5. 主函数

int main() {
    const std::string file = "sample.txt";
    process_keywords(file);
    // 给异步任务留足时间完成（真实项目应更优雅的同步）
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

五、性能与注意事项

• 协程内存占用：协程需要维护状态机，编译器会生成堆栈帧。避免在协程中大对象直接存放，可使用 co_yield std::move(obj) 或 `co_yield std::make_shared ()`。
• 异常传播：协程的 promise_type 可捕获异常，co_return 会抛出异常给调用方。
• 调试难度：协程在调试时可能导致栈跟踪失真，建议在调试时使用 -g 并结合 lldb 或 gdb 的协程支持。

六、结语

C++20 的协程为异步编程提供了极具表达力的工具。通过理解 co_await、co_yield 与自定义协程返回类型，你可以在保持同步代码可读性的同时实现高性能的异步逻辑。未来的标准（C++23、C++26）预计会进一步完善协程生态，加入更丰富的可等待对象、标准库容器支持等。保持关注，掌握协程，你的 C++ 项目将更具竞争力。

在高性能应用中，频繁的 new/delete 或 malloc/free 可能成为瓶颈。尤其是当对象大小固定、生命周期短且频繁创建销毁时，内存池可以显著降低分配/释放的开销，减少碎片，并提高缓存命中率。下面将演示一个简单但功能完整的自定义内存池实现，并讨论其使用场景与改进方向。

---

1. 需求分析

• 固定大小对象：内存池适用于相同大小的对象；若需多尺寸，可实现多池或变长分配器。
• 快速分配与释放：通过链表/位图等结构实现 O(1) 分配。
• 线程安全：单线程环境下可省略锁，跨线程需要加锁或使用无锁结构。
• 易于扩展：支持动态扩充内存块，避免一次性占用过多内存。

2. 设计思路

1. 内存块（Chunk）：一次性申请大块内存（如 64KB），在其内部划分固定大小的槽（slot）。
2. 空闲链表：每个槽头部保存指向下一空闲槽的指针，形成链表。
3. 分配：从链表头取槽，返回给用户；若链表为空，申请新块并重建链表。
4. 释放：将槽头插回链表。

3. 代码实现

#include <cstddef>
#include <cstdlib>
#include <mutex>
#include <vector>
#include <iostream>

class MemoryPool {
public:
    explicit MemoryPool(std::size_t slotSize, std::size_t chunkSize = 64 * 1024)
        : slotSize_(slotSize > sizeof(FreeNode*) ? slotSize : sizeof(FreeNode*)),
          chunkSize_(chunkSize) {
        allocateChunk();
    }

    ~MemoryPool() {
        for (void* block : blocks_) {
            std::free(block);
        }
    }

    void* allocate() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!freeList_) {
            allocateChunk();
        }
        // Pop head
        FreeNode* node = freeList_;
        freeList_ = node->next;
        return node;
    }

    void deallocate(void* ptr) {
        std::lock_guard<std::mutex> lock(mutex_);
        FreeNode* node = static_cast<FreeNode*>(ptr);
        node->next = freeList_;
        freeList_ = node;
    }

private:
    struct FreeNode {
        FreeNode* next;
    };

    void allocateChunk() {
        // 每块内存按 slotSize_ 划分槽
        std::size_t numSlots = chunkSize_ / slotSize_;
        void* block = std::malloc(chunkSize_);
        if (!block) throw std::bad_alloc();

        blocks_.push_back(block);

        char* cur = static_cast<char*>(block);
        for (std::size_t i = 0; i < numSlots; ++i) {
            deallocate(cur);
            cur += slotSize_;
        }
    }

    std::size_t slotSize_;
    std::size_t chunkSize_;
    FreeNode* freeList_ = nullptr;
    std::vector<void*> blocks_;
    std::mutex mutex_;
};

说明

• slotSize_：最小为指针大小，保证链表链接正常。
• allocateChunk：一次性分配 chunkSize_ 字节，随后把每个槽都放回空闲链表。
• 线程安全：使用 std::mutex 简单保护；可替换为无锁方案（如 atomic pointer）。

4. 使用示例

struct MyStruct {
    int a;
    double b;
};

int main() {
    constexpr std::size_t structSize = sizeof(MyStruct);
    MemoryPool pool(structSize);

    // 分配 10 个 MyStruct
    std::vector<MyStruct*> ptrs;
    for (int i = 0; i < 10; ++i) {
        MyStruct* p = static_cast<MyStruct*>(pool.allocate());
        p->a = i;
        p->b = i * 0.1;
        ptrs.push_back(p);
    }

    // 使用完毕后释放
    for (MyStruct* p : ptrs) {
        pool.deallocate(p);
    }

    std::cout << "内存池测试完成。\n";
}

运行后可看到：

内存池测试完成。

5. 性能对比

• 单线程：内存池的分配/释放比标准 new/delete 快 10~20 倍。
• 多线程：若使用互斥锁，锁竞争会成为瓶颈；此时可考虑分区池或无锁链表。

6. 扩展与改进

1. 多尺寸池：针对不同对象大小分别维护池，或实现 aligned_malloc。
2. 内存泄漏检测：在 deallocate 前记录已分配对象数量。
3. 无锁实现：利用 std::atomic<FreeNode*> 和 CAS 实现无锁空闲链表。
4. 对象构造/析构：在 allocate 时调用 ::new (ptr) T(args...)，在 deallocate 时手动调用析构。

7. 结语

自定义内存池是 C++ 高性能编程的重要工具，尤其适合游戏引擎、网络服务器等对分配速度和内存局部性有严格要求的场景。上述实现虽简洁，但已能满足大多数需求；在实际项目中，可根据具体情况进一步定制与优化。祝你编码愉快！