**C++20 模块化编程：实现模块的基本步骤**

作者

在 C++20 之前，C++ 项目往往依赖于头文件和预编译文件（.pch）来管理代码组织和编译依赖。随着 C++20 标准正式引入模块（modules），开发者得到了更清晰的接口定义、编译加速以及更严密的命名空间控制。下面我们从概念到实践，系统梳理如何在项目中引入并使用 C++20 模块。

1. 模块概览

关键概念 说明
模块 一个独立的编译单元，包含公共接口（模块接口）和私有实现（模块实现）。
模块接口文件 通常以 .ixx 或 .cppm 为后缀，声明模块名和导出（export）内容。
模块实现文件 包含非导出实现代码，编译为模块化的二进制文件（.mii）。
模块导入 通过 import 模块名; 语句将模块导入到其他文件。

2. 步骤一：准备编译器与工具链

  • 编译器：目前 GCC 10+、Clang 11+、MSVC 16.8+ 已经支持模块。
  • 构建系统：CMake 3.20+ 通过 target_sources(... PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/module.ixx) 能直接识别模块。
  • 编译选项：开启 -fmodules-ts（GCC/Clang）或 /std:c++20（MSVC），并根据需要添加 -fmodule-file 等。

3. 步骤二：编写模块接口文件

// math.ixx
export module math;          // 定义模块名

export namespace math {
    export int add(int a, int b);
    export int sub(int a, int b);
}
  • export 前置词可出现在模块名、命名空间和成员声明前，决定哪些符号对外可见。
  • 如果不想导出整个命名空间，可以只导出单个函数。

4. 步骤三：编写模块实现文件

// math_impl.cpp
module math;                 // 引入模块实现

int math::add(int a, int b) { return a + b; }
int math::sub(int a, int b) { return a - b; }
  • module math; 用于声明此文件属于 math 模块，实现文件不能使用 export。
  • 实现文件通常不导出任何符号，所有导出都是在接口文件中完成。

5. 步骤四：在其他文件中使用模块

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

#include <iostream>

int main() {
    std::cout << "add: " << math::add(3, 4) << '\n';
    std::cout << "sub: " << math::sub(10, 7) << '\n';
    return 0;
}
  • import math; 语句相当于传统的 #include，但不展开源文件，只加载编译好的模块接口。
  • 由于模块内部不包含实现细节，编译器在链接时自动把实现文件关联。

6. 步骤五：构建配置（CMake 示例）

cmake_minimum_required(VERSION 3.23)
project(ModuleDemo LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_library(math STATIC
    math.ixx          # 模块接口
    math_impl.cpp     # 模块实现
)
target_include_directories(math PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

add_executable(main main.cpp)
target_link_libraries(main PRIVATE math)
  • add_library 将接口文件和实现文件一起编译为静态库。
  • CMake 3.23+ 会自动识别模块文件，生成相应的编译单元。

7. 性能与构建加速

场景 传统做法 模块化做法
头文件解析 每个翻译单元都解析一次头文件 只解析一次接口，后续编译直接引用二进制接口
变更编译 头文件修改导致所有包含它的文件重新编译 只影响修改的模块文件，其它文件保持不变
预编译 PCH 需要手动维护，冲突难以排查 模块本身即为编译单元，避免冲突

8. 常见坑与解决方案

  1. 模块依赖循环

    • 解决：使用 export module 时，只能导出一次，避免在实现文件里再次 export。如果需要跨模块引用，使用 import 而不是 #include。

  2. 编译器不支持完整模块

    • 解决：确保使用最新的编译器版本；若使用旧版 GCC，可开启 -fmodules-ts 并使用 -fprebuilt-module-path 指定预编译模块路径。

  3. 第三方库未模块化

    • 解决：将其头文件包裹为 module 接口，或使用传统 #include 方式。

  4. 链接错误

    • 检查模块实现是否已编译为二进制；确保 CMake 的 target_link_libraries 指定了对应模块。

9. 进阶：模块化与 constexpr、inline 的结合

  • 模块接口文件可直接使用 inline constexpr 定义常量，避免头文件膨胀。
  • 通过模块导入，constexpr 计算仅在模块编译时完成，后续使用时无需再次执行。

10. 结语

C++20 模块化是 C++ 语言发展史上的一次重要跃迁。它不仅让代码更易维护，也显著提升了编译性能。通过本文的基本步骤，你可以快速在项目中引入模块，体验更清晰的接口与更快的编译速度。祝你编码愉快！

如何在C++中实现线程安全的单例模式？

作者

在多线程环境下，单例模式需要保证只有一个实例被创建，并且该实例在所有线程间共享。下面介绍几种常见的实现方式，并比较它们的优缺点。

1. 局部静态变量（C++11及以后）

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance; // 编译器保证线程安全
        return instance;
    }
    // 其他成员函数
private:
    Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

优点

  • 代码最简洁，直接利用语言特性。
  • 编译器负责线程同步，无需手动写锁。
  • 延迟初始化，第一次调用时才创建。

缺点

  • 对于C++11之前的编译器不适用。
  • 可能会出现“static initialization order fiasco”问题，虽然在函数内部局部静态已解决，但全局静态依旧需要注意。

2. 带锁的双重检查锁（DCL）

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

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mtx_;

优点

  • 兼容老版本C++。
  • 只在第一次初始化时加锁，后续访问速度较快。

缺点

  • 需要注意内存可见性问题（在C++11前未保证）。
  • 实现相对复杂，易出错。

3. 静态局部指针与 std::call_once

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

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

优点

  • 兼容C++11及以后。
  • std::call_once 语义清晰，线程安全。
  • 延迟初始化与双重检查类似。

缺点

  • 需要手动管理内存释放（可使用智能指针改进）。

4. Meyer’s 单例（函数内部静态对象）+ 智能指针

class Singleton {
public:
    static std::shared_ptr <Singleton> instance() {
        static std::shared_ptr <Singleton> ptr(new Singleton());
        return ptr;
    }
private:
    Singleton() = default;
};

优点

  • 自动内存管理，避免手动 delete。
  • 与 C++11 的线程安全局部静态兼容。

缺点

  • 共享计数开销，若单例不需要多次获取，略显冗余。

5. 经典静态成员实现（全局变量）

class Singleton {
public:
    static Singleton& getInstance() {
        return *instance_;
    }
private:
    Singleton() = default;
    static Singleton* instance_;
};

Singleton* Singleton::instance_ = new Singleton();

优点

  • 简单实现，直接返回引用。

缺点

  • 全局初始化顺序不确定，可能导致“静态初始化顺序问题”。
  • 无法在需要时才初始化。

选择建议

  • C++11 及以后：推荐使用局部静态变量或 std::call_once，代码最简洁且线程安全。
  • C++03：若需兼容旧编译器，使用双重检查锁（DCL）或 std::call_once 的老实现。
  • 性能极端要求：如果后续访问频繁且不想再加锁，std::call_once 仍是最优。
  • 需要自动析构：可结合 std::shared_ptr 或 std::unique_ptr，避免手动释放。

小结

线程安全单例是 C++ 设计模式中的常见难题。理解每种实现的内部机制，可以帮助我们在不同的项目需求与编译器环境下做出合适选择。通过利用现代 C++ 的特性（如线程安全的局部静态、std::call_once、智能指针），可以大幅降低代码复杂度与错误率，从而编写出既简洁又可靠的单例类。

C++20 协程实战：从异步 I/O 到游戏循环的完整实现

作者

协程是 C++20 引入的一项强大特性，它通过 co_await、co_yield 和 co_return 让异步编程更加直观、易读。本文将带你深入了解协程的底层实现原理，结合实际案例演示如何在 C++ 中使用协程构建高效的异步 I/O、数据流处理以及游戏循环。

1. 协程的基础概念

1.1 什么是协程？

协程（Coroutine）是一种轻量级的函数，它可以在执行过程中暂停并恢复。与传统线程相比，协程的切换成本极低，内存占用更小，适合在 I/O 密集型或高频切换场景下使用。

1.2 协程的三大关键词

关键词 用途 典型示例
co_await 等待异步操作完成 int result = co_await asyncRead();
co_yield 产生序列值 co_yield i;
co_return 返回值并结束协程 co_return result;

2. 协程的底层实现原理

2.1 协程句柄（std::coroutine_handle）

协程句柄是协程的核心对象，负责管理协程的生命周期。它通过内部指针维护协程帧（栈帧），并提供 resume()、destroy() 等操作。

auto h = std::coroutine_handle<>::from_promise(promise);
h.resume();   // 继续执行协程
h.destroy();  // 销毁协程

2.2 协程状态机

编译器会把协程函数自动转换为状态机。每个 co_await、co_yield、co_return 对应一个状态点。状态机通过内部 promise_type 的 await_suspend、await_resume 等成员实现。

2.3 内存布局

  • 协程帧：包含局部变量、返回地址、协程状态等信息，存放在堆上（通过 operator new 分配）。
  • promise_type：实现协程返回值、异常处理以及 get_return_object() 等。

3. 实例：基于协程的异步文件读取

下面演示一个简易的异步文件读取器，利用协程实现非阻塞 I/O。

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

struct AsyncReadResult {
    std::string data;
    bool eof;
};

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

    std::coroutine_handle <promise_type> handle;
    ~AsyncFileReader() { if (handle) handle.destroy(); }

    AsyncReadResult get() { return handle.promise().result; }
};

AsyncFileReader asyncReadFile(const std::string& filename, std::size_t chunkSize) {
    std::ifstream file(filename, std::ios::binary);
    if (!file) co_return { "", true };

    std::string buffer(chunkSize, '\0');
    while (file.read(buffer.data(), chunkSize) || file.gcount() > 0) {
        buffer.resize(file.gcount());
        co_yield AsyncReadResult{buffer, false};
        buffer.assign(chunkSize, '\0');
    }
    co_return { "", true }; // EOF
}

int main() {
    auto reader = asyncReadFile("sample.bin", 4096);
    for (auto chunk : reader) {
        std::cout << "Read " << chunk.data.size() << " bytes.\n";
    }
    std::cout << "File reading finished.\n";
}

说明

  • asyncReadFile 在每次读取完成后 co_yield 一个 AsyncReadResult。
  • main 通过范围 for 循环遍历每个协程生成的块，达到非阻塞效果。
  • 若需真正的异步 I/O（如使用 io_uring 或 Windows IOCP），需要在 await_suspend 中挂起协程并注册回调。

4. 协程在数据流处理中的应用

协程非常适合实现流式处理，例如：

auto filter = [](auto&& stream, auto&& predicate) -> auto {
    while (co_yield auto x = stream.next()) {
        if (predicate(x)) co_yield x;
    }
};

使用 co_yield 生成无限序列或处理网络数据包时，可以让代码保持同步可读。

5. 在游戏循环中的协程使用

在游戏引擎中，协程可以用来实现：

  1. 异步资源加载：后台加载纹理、模型，加载完成后恢复主线程。
  2. 动画控制：让角色动画以帧为单位逐步执行，支持暂停、回放。
  3. 状态机实现：用 co_yield 表达不同状态，避免大量 switch。
struct AI {
    std::string name;
    std::coroutine_handle<> h;

    AI(const std::string& n) : name(n) {}

    void start() {
        h = walk().handle;
        h.resume();
    }

    auto walk() -> std::coroutine_handle<> {
        while (true) {
            std::cout << name << " walking.\n";
            co_await std::suspend_always(); // 等待下一帧
        }
    }
};

每帧调用 h.resume() 即可。

6. 协程常见陷阱与调试技巧

陷阱 原因 解决方案
协程对象持久化导致悬空引用 协程内部引用外部对象生命周期短 使用 std::shared_ptr 或手动管理资源
频繁创建协程导致性能下降 每个协程都分配堆帧 复用协程对象或使用 std::generator
断点调试不连贯 协程切换隐藏在生成器内部 使用 -g 并结合 gdb 的 frame 命令

7. 结语

C++20 的协程为异步编程提供了天然的语法糖，使代码更接近同步写法，同时保持了高性能。无论是文件 I/O、网络通信还是游戏状态机，协程都能以简洁的方式解决传统 callback 的复杂性。随着标准的进一步完善和第三方库（如 asio、cppcoro 等）的成熟，协程将在更广阔的领域得到应用。欢迎大家尝试将协程引入自己的项目，感受其带来的代码简洁与运行效率提升。

如何在C++中实现自定义的智能指针？

作者

在 C++ 标准库中，std::shared_ptr 和 std::unique_ptr 已经满足大多数资源管理需求，但有时我们需要一种更符合业务需求的自定义智能指针。下面将演示一个简易但功能完整的 MySharedPtr 实现，包括引用计数、线程安全、以及自定义删除器。代码仅供学习参考，实际生产环境请使用标准库或成熟的第三方实现。

#pragma once
#include <atomic>
#include <cstddef>
#include <memory>
#include <iostream>
#include <utility>

template<typename T, typename Deleter = std::default_delete<T>>
class MySharedPtr {
public:
    // 构造函数：直接接受裸指针
    explicit MySharedPtr(T* ptr = nullptr, Deleter del = Deleter())
        : ptr_(ptr), deleter_(del) {
        if (ptr_) {
            ref_count_ = new std::atomic <size_t>(1);
        } else {
            ref_count_ = nullptr;
        }
    }

    // 构造函数：接受已有的 MySharedPtr（复制构造）
    MySharedPtr(const MySharedPtr& other) noexcept
        : ptr_(other.ptr_), deleter_(other.deleter_), ref_count_(other.ref_count_) {
        increment();
    }

    // 移动构造
    MySharedPtr(MySharedPtr&& other) noexcept
        : ptr_(other.ptr_), deleter_(std::move(other.deleter_)), ref_count_(other.ref_count_) {
        other.ptr_ = nullptr;
        other.ref_count_ = nullptr;
    }

    // 赋值运算符（拷贝）
    MySharedPtr& operator=(const MySharedPtr& other) noexcept {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            deleter_ = other.deleter_;
            ref_count_ = other.ref_count_;
            increment();
        }
        return *this;
    }

    // 赋值运算符（移动）
    MySharedPtr& operator=(MySharedPtr&& other) noexcept {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            deleter_ = std::move(other.deleter_);
            ref_count_ = other.ref_count_;
            other.ptr_ = nullptr;
            other.ref_count_ = nullptr;
        }
        return *this;
    }

    ~MySharedPtr() { release(); }

    // 解引用操作
    T& operator*() const noexcept { return *ptr_; }
    T* operator->() const noexcept { return ptr_; }
    T* get() const noexcept { return ptr_; }

    // 引用计数
    size_t use_count() const noexcept { return ref_count_ ? ref_count_->load() : 0; }

    // 判断是否唯一所有者
    bool unique() const noexcept { return use_count() == 1; }

private:
    void increment() noexcept {
        if (ref_count_) ref_count_->fetch_add(1, std::memory_order_relaxed);
    }

    void release() noexcept {
        if (ref_count_ && ref_count_->fetch_sub(1, std::memory_order_acq_rel) == 1) {
            deleter_(ptr_);
            delete ref_count_;
        }
    }

    T* ptr_;
    Deleter deleter_;
    std::atomic <size_t>* ref_count_;
};

关键点说明

  1. 引用计数

    • 使用 `std::atomic ` 以保证多线程环境下计数安全。
    • fetch_add/fetch_sub 与 memory_order_relaxed 或 acq_rel 保证正确的同步。

  2. 自定义删除器

    • 模板参数 Deleter 默认使用 `std::default_delete `。
    • 允许用户传入 lambda 或自定义 functor 来控制资源释放逻辑，例如：MySharedPtr<MyFile, FileCloser>(filePtr, FileCloser{})。

  3. 构造/析构/赋值

    • 复制构造时计数加 1；移动构造时转移所有权。
    • 赋值运算符先释放自身资源，再做复制或移动。

  4. 使用方式 

    struct MyStruct { int x; };
MySharedPtr <MyStruct> p1(new MyStruct{10});
MySharedPtr <MyStruct> p2 = p1;            // 共享所有权
std::cout << p1.use_count() << std::endl; // 输出 2

与标准库的区别

  • 性能：标准库实现使用控制块来分离数据和引用计数，进一步优化。
  • 异常安全：标准库保证异常安全，本文示例简化了错误处理。
  • 特性：标准库提供 weak_ptr、自定义控制块、make_shared 等高级功能。

适用场景

  • 学习指针管理和 RAII 的实现细节。
  • 在不允许引入 ` `（如古老编译器或特殊项目）时使用。
  • 需要特定的删除逻辑但不想使用标准库的完整实现。

小结

自定义智能指针可以帮助我们更深入理解 C++ 内存管理机制。通过模板化的删除器、线程安全的引用计数以及完整的生命周期管理，MySharedPtr 能够在多种环境下安全地共享资源。若项目规模较大或需要更完善的功能，建议直接使用 std::shared_ptr，以减少维护成本和潜在 bug。

**C++20 std::span 与 std::vector：实现高效子数组操作**

作者

在 C++20 之前，处理数组或容器的子区段通常需要手动管理指针、长度，或者使用 std::array、std::vector 的迭代器和 std::copy 等操作，这些都容易出现边界错误或多余的拷贝。C++20 引入了 std::span，它是一个轻量级、无所有权的视图，用来描述一段连续内存。结合 std::vector 的动态管理，std::span 可以在不产生拷贝、保持安全性的前提下，实现对子数组的快速访问。以下是使用 std::span 与 std::vector 的完整示例与说明。

1. std::span 简介

template<class T, std::size_t Extent = std::dynamic_extent>
class span;
  • 无所有权：span 只是对已有数据的引用，它不负责内存分配或释放。
  • 零拷贝：创建 span 时不进行数据拷贝，直接引用原始内存。
  • 安全性：可以通过 empty(), size(), data() 等成员进行安全检查。

2. 示例：从 `std::vector

` 获取子区段 “`cpp #include #include #include int main() { std::vector numbers{ 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; // 取出第3到第6个元素（索引2到5） std::span subSpan{ numbers.data() + 2, 4 }; // 4个元素 // 打印子区段 for (auto v : subSpan) std::cout 观察到 `subSpan` 的修改直接影响了原始 `vector`，说明 `span` 并未拷贝数据。 — ### 3. 典型使用场景 1. **函数参数** 传统的函数签名往往需要 `T* begin, T* end` 或 `T* ptr, size_t count`。使用 `std::span` 可以一次性传递区段，接口更简洁且易读。 “`cpp void process(span data) { // 处理 } process(numbers); // 传整个 vector process(numbers.subspan(3, 5)); // 只处理 4~8 个元素 “` 2. **迭代器封装** 对于非连续容器（如 `std::list`）不适用；但对于 `std::array`、`std::vector`、C 风格数组，`span` 提供了统一的访问方式。 3. **性能敏感代码** 避免无谓的拷贝、减少栈内存开销（`span` 本身只有两指针），提升缓存命中率。 — ### 4. 注意事项与陷阱 – **生命周期**：`span` 必须引用的底层数据在 `span` 生命周期内保持有效。 “`cpp std::span s; { std::vector temp{1, 2, 3}; s = temp; // temp 失效，s 成为悬空引用 } “` – **可变性**：如果传递给 `const span `，无法修改数据；如果想修改，确保底层容器可写。 – **多维数组**：`std::span` 本身是一维的，但可以嵌套使用 `std::span>` 或者使用 `std::span>` 处理二维矩阵。 — ### 5. 进一步扩展：使用 `std::span` 结合 `std::span` 进行内存映射 当需要将文件或网络数据映射为字节视图时，`std::span` 非常适合。 “`cpp #include #include #include #include int main() { std::ifstream file(“data.bin”, std::ios::binary); file.seekg(0, std::ios::end); std::size_t size = file.tellg(); file.seekg(0, std::ios::beg); std::vector buffer(size); file.read(reinterpret_cast(buffer.data()), size); std::span dataSpan{ buffer }; // 读取整数 std::uint32_t val = *reinterpret_cast(dataSpan.data()); std::cout

如何在 C++20 中使用 std::expected 处理错误？

作者

在 C++23 中正式引入了 std::expected，但在 C++20 之前已经可以通过第三方实现（如 tl::expected）或自己实现一个简化版来获得类似功能。std::expected 提供了一种更安全、更可读的方式来处理可能失败的函数，而不是传统的异常或错误码。下面我们从概念、实现、使用示例以及与异常的比较四个方面详细阐述。

1. 概念与设计目标

  • 成功值（Success）：std::expected<T, E> 包含一个成功值 T 或错误值 E。
  • 无错误值：与 `std::optional ` 类似，只是 `std::optional` 只表示存在或不存在一个值，而 `std::expected` 更细致，能同时给出错误原因。
  • 避免异常：对于需要频繁返回错误或在性能敏感路径中，使用 expected 可以减少异常的开销。
  • 可组合：可以轻松链式调用多个返回 expected 的函数，利用 operator>> 或 .and_then() 进行错误传播。

2. 简化版实现（C++20 语法）

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

template<class T, class E>
class expected {
public:
    // 构造成功值
    expected(const T& val) : value_(val) {}
    expected(T&& val) : value_(std::move(val)) {}

    // 构造错误值
    expected(const E& err) : value_(err) {}
    expected(E&& err) : value_(std::move(err)) {}

    // 判断是否成功
    explicit operator bool() const noexcept {
        return std::holds_alternative <T>(value_);
    }

    // 访问成功值（未检查）
    const T& value() const & { return std::get <T>(value_); }
    T& value() & { return std::get <T>(value_); }
    const T&& value() const && { return std::get <T>(std::move(value_)); }
    T&& value() && { return std::get <T>(std::move(value_)); }

    // 访问错误值（未检查）
    const E& error() const & { return std::get <E>(value_); }
    E& error() & { return std::get <E>(value_); }
    const E&& error() const && { return std::get <E>(std::move(value_)); }
    E&& error() && { return std::get <E>(std::move(value_)); }

private:
    std::variant<T, E> value_;
};

注意：上面示例仅展示核心功能，缺少诸如 and_then, transform, value_or 等实用成员。实际项目请使用成熟库或自行扩展。

3. 使用示例

假设我们实现一个简单的文件读取函数 read_file，返回内容或错误信息：

expected<std::string, std::string> read_file(const std::string& path) {
    std::ifstream in(path);
    if (!in.is_open()) {
        return expected<std::string, std::string>("无法打开文件：" + path);
    }
    std::stringstream buffer;
    buffer << in.rdbuf();
    return expected<std::string, std::string>(buffer.str());
}

调用者可以链式处理：

auto result = read_file("example.txt");
if (result) {
    std::cout << "文件内容长度: " << result.value().size() << '\n';
} else {
    std::cerr << "读取失败: " << result.error() << '\n';
}

如果我们需要将读取结果进一步解析为 JSON，可以使用 and_then：

auto json_result = read_file("config.json")
    .and_then([](std::string content) -> expected<nlohmann::json, std::string> {
        try {
            return expected<nlohmann::json, std::string>(nlohmann::json::parse(content));
        } catch (const std::exception& e) {
            return expected<nlohmann::json, std::string>("JSON 解析错误: " + std::string(e.what()));
        }
    });

if (json_result) {
    // 成功
} else {
    std::cerr << json_result.error() << '\n';
}

提示：如果你使用的是 C++23 标准库的 std::expected，上述链式调用将更简洁，例如 read_file(...).transform(...).and_then(...)。

4. 与异常的比较

方面 expected 异常
错误传播 通过返回值链式传播 通过抛异常自动传播
性能 适用于高频路径，无抛异常开销 抛异常在异常路径会产生堆栈展开成本
可读性 明确指出函数可能失败 需要查看调用栈或异常处理逻辑
类型安全 明确返回值类型 异常类型可多样但不强制
适用场景 IO、解析、算法错误等 需要中断执行、资源回收等

5. 进阶技巧

  • 自定义错误类型：使用 enum class ErrorCode 或结构体来统一错误码，方便调试与日志。
  • 宏化错误生成：定义 MAKE_ERROR(msg) 宏，简化错误值构造。
  • 与 std::optional 混用：在函数既可能返回值也可能返回空值时，可以先返回 `std::optional `，再包装为 `expected`。

6. 小结

std::expected 在 C++23 中正式标准化，它为错误处理提供了一种更直观、类型安全、无异常的方案。即便在 C++20 环境下，通过第三方实现或自定义简化版也能大幅提升代码可读性与错误传播效率。建议在项目中逐步引入 expected，替代传统的错误码或异常方式，尤其是在性能敏感或多路径错误处理场景中。

C++ 中的内存映射文件（mmap）使用与实现

作者

在现代 C++ 开发中，内存映射文件（memory‑mapped files）提供了一种高效读取大文件或共享数据的方式。与传统的文件 I/O（fread/fwrite、fstream）相比，mmap 能够把文件映射到进程地址空间，使得对文件内容的访问像访问普通内存一样简单，且由操作系统负责缓存与磁盘同步。

1. 为什么要使用 mmap？

  • 性能提升：文件内容被映射后，读取不需要系统调用，数据直接在内存中访问，减少了数据拷贝开销。
  • 延迟加载：文件被按需加载，只有实际访问的页面才会被调入内存，降低初始加载时间。
  • 共享内存：不同进程可以映射同一文件，内存页会被共享，适用于 IPC。
  • 大文件支持：对于超过 2GB 的文件，mmap 可以一次性映射整个文件，避免缓冲区大小限制。

2. 关键 API（POSIX 版本）

int   open(const char *pathname, int flags, ...);        // 打开文件
void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);                       // 映射文件
int   munmap(void *addr, size_t length);                 // 解除映射
int   close(int fd);                                     // 关闭文件
  • prot：访问权限，如 PROT_READ | PROT_WRITE。
  • flags：映射属性，如 MAP_SHARED（共享）或 MAP_PRIVATE（写时复制）。
  • offset：文件偏移，通常为 0。

3. 简单示例：读取文本文件

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <iostream>
#include <cstring>

int main() {
    const char *file = "sample.txt";

    // 1. 打开文件
    int fd = open(file, O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    // 2. 获取文件大小
    struct stat st;
    if (fstat(fd, &st) < 0) {
        perror("fstat");
        close(fd);
        return 1;
    }
    size_t len = st.st_size;

    // 3. 映射文件
    void *map = mmap(nullptr, len, PROT_READ, MAP_PRIVATE, fd, 0);
    if (map == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    // 4. 处理内容（这里直接输出）
    std::cout.write(static_cast<char*>(map), len);
    std::cout << std::endl;

    // 5. 解除映射并关闭文件
    munmap(map, len);
    close(fd);
    return 0;
}

运行步骤

  1. 用 g++ -std=c++17 mmap_example.cpp -o mmap_example 编译。
  2. 准备一个 sample.txt，填入内容。
  3. 运行 ./mmap_example 即可看到文件内容。

4. 写入操作（MAP_SHARED）

如果想在映射区域修改内容并同步回磁盘，需要使用 MAP_SHARED 并确保 PROT_WRITE：

void *map = mmap(nullptr, len, PROT_READ | PROT_WRITE,
                 MAP_SHARED, fd, 0);

此时，对映射内存的写操作会直接写回文件。请注意：

  • 写时复制（MAP_PRIVATE）不会影响原文件。
  • 必须确保映射内存的生命周期与文件描述符保持一致。

5. 注意事项

场景 说明
多线程 每个线程共享同一映射区域时，要注意同步，避免数据竞争。
大文件 mmap 能一次映射整个文件，但如果文件非常大，仍需根据系统内存情况决定是否分段映射。
关闭文件 关闭 fd 后映射仍然有效，但不建议在映射后立即关闭。
取消映射 必须先 munmap 再 close，否则会导致资源泄漏。

6. 高级用法：映射一个文件的某个区域

void *map = mmap(nullptr, page_size, PROT_READ,
                 MAP_PRIVATE, fd, offset);

通过调整 offset 与 length，可以只映射文件的一部分，常用于内存映射数据库、日志文件切片等场景。

7. 小结

内存映射文件是 C++ 开发中提高 I/O 性能的重要手段。掌握 mmap 的基本调用方式与使用场景，能够在处理大文件、实现高性能服务器或跨进程共享数据时，获得显著的性能优势。需要注意的是，尽管 mmap 简化了文件访问，但它也带来了与内存管理相关的细节，如页面错误、同步与一致性问题，使用时应结合具体业务场景慎重选择。

C++20 中的概念（Concepts）如何提高模板代码可读性

作者

在 C++20 标准中，概念（Concepts）被引入以解决传统模板编程中常见的“错误消息混乱”与“接口不明确”问题。它们通过对模板参数进行约束，为编译器提供更精确的类型信息，从而使模板的意图更加清晰，编译错误信息更易于理解。下面我们从概念的定义、使用方式、优点以及实践案例四个方面展开讨论。

1. 概念的基本语法

概念是一种类型约束，语法类似于类型别名（using）但后面跟随一系列逻辑表达式。最常见的形式如下： 

template<typename T>
concept EqualityComparable = requires(T a, T b) {
    { a == b } -> std::convertible_to <bool>;
    { a != b } -> std::convertible_to <bool>;
};
  • requires 子句中列出需要满足的表达式或语义。
  • `-> std::convertible_to ` 是约束的结果类型，要求表达式返回可转换为 `bool` 的类型。

2. 在函数模板中的使用

通过把概念直接写在模板参数列表中，编译器会在满足约束前给出编译错误。 

template<EqualityComparable T>
bool equals(const T& lhs, const T& rhs) {
    return lhs == rhs;
}

如果尝试传入不满足 EqualityComparable 的类型，编译器会报错类似：“’int’ does not satisfy EqualityComparable”。错误信息清晰指向了缺失的操作符。

3. 约束组合与继承

概念可以相互组合，实现更细粒度的约束。 

template<typename T>
concept Integral = std::is_integral_v <T>;

template<Integral T>
concept PositiveIntegral = T > 0;

组合后可直接在模板参数中使用 PositiveIntegral，使代码更具可读性。

4. 与 SFINAE 的对比

传统的可替换失败不是错误（SFINAE）实现约束需要大量模板元编程技巧，代码冗长且难以维护。概念则通过语言层面提供约束，消除了隐式特化与重载的复杂性。

5. 编译器支持与性能

主要主流编译器（GCC 10+, Clang 10+, MSVC 19.32+）已完整支持概念。虽然概念在编译阶段会产生额外的检查，但对运行时性能没有影响。编译器利用约束信息进行更好地模板实例化和错误诊断。

6. 实践案例：实现一个安全的容器迭代器

template<typename T>
concept RandomAccessIterator = requires(T it, T it2) {
    *it;                      // 解引用
    it + 1;                   // 加法
    it - it2;                  // 差值
    it < it2;                  // 比较
};

template<RandomAccessIterator It>
auto distance(It first, It last) -> std::ptrdiff_t {
    return last - first;
}

此处使用 RandomAccessIterator 约束，确保 distance 只接受随机访问迭代器。若传入线性迭代器，编译器会报错提示不满足约束。

7. 结语

概念为 C++ 模板编程带来了类型安全、可读性与易维护性的新层级。通过清晰的约束，程序员可以更快定位错误，也让库作者在接口设计时避免不必要的歧义。随着 C++20 逐渐成为主流，掌握概念已成为现代 C++ 开发者必备的技能之一。

如何在C++中实现自定义智能指针的多线程安全？

作者

在多线程环境下使用智能指针时，最常见的问题是如何保证引用计数的原子性，从而避免数据竞争和悬空指针。下面通过一个完整的示例，演示如何使用 C++11/14/17 的原子操作和互斥锁，实现一个线程安全的 SharedPtr。

1. 设计思路

  • 引用计数：使用 std::atomic<std::size_t> 保存引用计数，保证自增、自减操作是原子性的。
  • 控制块：每个 SharedPtr 指向一个控制块（ControlBlock），控制块中存放引用计数和删除回调。
  • 删除回调：使用模板化的 DeleteFunc，支持普通 delete、delete[] 以及自定义删除器。
  • 线程安全：所有引用计数操作均使用原子操作；在 reset()、swap() 等需要修改指针的操作时使用 std::mutex 或 std::lock_guard 进行互斥。

2. 控制块实现

#include <atomic>
#include <mutex>
#include <memory>

template<typename T, typename Deleter = std::default_delete<T>>
struct ControlBlock {
    std::atomic<std::size_t> ref_count{1};
    Deleter deleter;

    ControlBlock(Deleter d) : deleter(std::move(d)) {}
};

3. SharedPtr 基类

template<typename T, typename Deleter = std::default_delete<T>>
class SharedPtr {
public:
    using pointer = T*;
    using element_type = T;

    SharedPtr() noexcept : ptr_(nullptr), ctrl_(nullptr) {}
    explicit SharedPtr(T* ptr, Deleter d = Deleter()) noexcept
        : ptr_(ptr), ctrl_(new ControlBlock<T, Deleter>(std::move(d))) {}

    // 拷贝构造
    SharedPtr(const SharedPtr& other) noexcept {
        acquire(other.ptr_, other.ctrl_);
    }

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

    ~SharedPtr() {
        release();
    }

    // 拷贝赋值
    SharedPtr& operator=(const SharedPtr& rhs) noexcept {
        if (this != &rhs) {
            release();
            acquire(rhs.ptr_, rhs.ctrl_);
        }
        return *this;
    }

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

    // 访问
    T& operator*() const noexcept { return *ptr_; }
    T* operator->() const noexcept { return ptr_; }
    T* get() const noexcept { return ptr_; }
    std::size_t use_count() const noexcept { return ctrl_ ? ctrl_->ref_count.load() : 0; }
    explicit operator bool() const noexcept { return ptr_ != nullptr; }

    void reset(T* ptr = nullptr, Deleter d = Deleter()) noexcept {
        std::lock_guard<std::mutex> lock(mtx_);
        if (ptr_ != ptr) {
            release();
            if (ptr) {
                ptr_ = ptr;
                ctrl_ = new ControlBlock<T, Deleter>(std::move(d));
            } else {
                ptr_ = nullptr;
                ctrl_ = nullptr;
            }
        }
    }

    void swap(SharedPtr& other) noexcept {
        std::lock_guard<std::mutex> lock(mtx_);
        std::swap(ptr_, other.ptr_);
        std::swap(ctrl_, other.ctrl_);
    }

private:
    void acquire(pointer p, ControlBlock<T, Deleter>* c) noexcept {
        ptr_ = p;
        ctrl_ = c;
        if (ctrl_) ctrl_->ref_count.fetch_add(1, std::memory_order_relaxed);
    }

    void release() noexcept {
        if (ctrl_ && ctrl_->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            ctrl_->deleter(ptr_);
            delete ctrl_;
        }
        ptr_ = nullptr;
        ctrl_ = nullptr;
    }

    pointer ptr_;
    ControlBlock<T, Deleter>* ctrl_;
    mutable std::mutex mtx_;  // 保护 reset 和 swap
};

4. 使用示例

#include <iostream>
#include <thread>
#include <vector>

void thread_func(SharedPtr <int> sp) {
    for (int i = 0; i < 1000; ++i) {
        // 读取
        int val = *sp;
        // 简单演示
        if (i % 200 == 0) std::cout << "Thread " << std::this_thread::get_id() << " reads " << val << '\n';
    }
}

int main() {
    auto sp = SharedPtr <int>(new int(42));

    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(thread_func, sp);

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

    std::cout << "Final use_count: " << sp.use_count() << '\n';
}

5. 关键点回顾

  1. 引用计数原子性：使用 std::atomic 的 fetch_add 与 fetch_sub，保证多线程环境下计数安全。
  2. 互斥锁：reset 与 swap 这类操作会修改内部指针或控制块指针，使用 std::mutex 防止并发冲突。
  3. 自定义删除器：模板化 Deleter 使得 SharedPtr 能够支持数组、文件句柄等资源。
  4. 性能考虑：大多数操作（operator*, operator->, use_count）不锁定，几乎不产生额外开销。

通过上述实现，你可以在自己的项目中直接使用 `SharedPtr

` 替代标准库中的 `std::shared_ptr`，并且保证在多线程环境下的安全性。若需要进一步优化，可考虑使用 `std::shared_ptr` 的 `use_count` 只读原子操作，或者使用更细粒度的锁策略。

**C++20 中的 ranges 库：从迭代器到管道式处理**

作者

C++20 引入了 <ranges> 标头，提供了一套完整的视图（view）、适配器（adapter）和算法（algorithm）集合，让我们能够像函数式编程一样以更简洁、更直观的方式操作容器。本文将从基础概念讲起，演示如何使用 ranges 进行高效、可读的代码编写，并讨论其与传统迭代器风格的区别与优势。

1. 视图（View）与适配器（Adapter）

  • 视图（view）：只读、惰性求值的数据序列，它不会拷贝底层容器，而是基于原始数据按需生成元素。
  • 适配器（adapter）：对视图进行加工（如过滤、映射、切片等），同样惰性求值。 
#include <vector>
#include <ranges>
#include <iostream>

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

    // 取偶数并翻倍
    auto result = v | std::views::filter([](int n){ return n % 2 == 0; })
                     | std::views::transform([](int n){ return n * 2; });

    for (int x : result)
        std::cout << x << ' ';   // 输出: 4 8 12
}

2. 主要适配器

适配器 功能 示例
views::filter 过滤 v | std::views::filter([](int n){ return n > 3; })
views::transform 映射 v | std::views::transform([](int n){ return n * n; })
views::take 取前 N 个 v | std::views::take(3)
views::drop 跳过前 N 个 v | std::views::drop(2)
views::reverse 反转 v | std::views::reverse
views::split 切割 std::string s = "a:b:c"; → s | std::views::split(':')

3. 组合使用与管道式风格

使用管道符号 |，可以将多个适配器串联，形成链式操作。整个链条惰性求值，直到真正需要访问元素时才会执行。

auto filtered = v 
    | std::views::filter([](int n){ return n % 2 != 0; })
    | std::views::transform([](int n){ return n * 3; })
    | std::views::take(4);

4. 与传统算法的对比

  • 可读性：传统算法往往需要多行 for 循环和临时容器，而 ranges 只需一行表达式。
  • 性能：视图惰性求值可避免不必要的拷贝与中间容器。
  • 可组合性：适配器可随意组合，易于扩展和维护。

5. 常见 pitfalls

  1. 容器生命周期：视图仅引用底层数据，若容器被销毁，视图失效。
  2. 多次遍历：某些适配器是一次性使用的（如 views::split），多次迭代会导致错误。
  3. 标准库实现差异：部分编译器对 ` ` 的支持仍不完整，建议使用 GCC 11+ 或 Clang 13+。

6. 小结

C++20 的 ranges 库为容器操作提供了更直观、更高效的方式。通过视图和适配器，我们可以像使用管道一样构造复杂的数据流，减少样板代码。掌握 ranges 的使用，将使你的 C++ 代码更现代、更易维护。祝编码愉快！