standrad c++

Modern C++ offers a lightweight, non-owning view into contiguous sequences called std::span. Introduced in C++20, std::span provides a safer and more expressive alternative to raw pointers and manual size handling. In this article, we explore why std::span is valuable, how to use it in practice, and a few common pitfalls to avoid.

1. What is std::span?

`std::span

` is essentially a pair of a pointer and a length that references a contiguous block of memory without taking ownership. It is template‑parameterized on the element type `T`, and it can be constructed from: – Raw pointers and length: `std::span s(ptr, n);` – C-style arrays: `int arr[5]; std::span s(arr);` – `std::array`, `std::vector`, `std::string`, and any other container with contiguous storage: `std::span s(vec);` – Another `std::span`: `std::span sub(s.subspan(2, 3));` Because it holds no ownership, `std::span` is cheap to copy and can be passed around like any other value type. ### 2. Why use std::span? 1. **Safety** – `std::span` carries size information, eliminating the risk of out‑of‑bounds access that plagues raw pointers. 2. **Expressiveness** – Function signatures that accept a contiguous block become clearer: `void process(std::span data)`. 3. **Interoperability** – It can seamlessly accept containers and raw arrays, making it a flexible bridge between legacy APIs and modern code. 4. **Performance** – Being a lightweight view, there is no additional allocation; it typically incurs no runtime cost beyond the pointer and size fields. ### 3. Example: Implementing a Generic Sum Function “`cpp #include #include #include #include template T sum(std::span values) { return std::accumulate(values.begin(), values.end(), T{}); } int main() { std::vector vec{1, 2, 3, 4, 5}; int arr[] = {10, 20, 30}; std::cout << "Sum of vector: " << sum(vec) << '\n'; std::cout << "Sum of array: " << sum(arr) << '\n'; // Subspan example std::span sub = std::span(vec).subspan(1, 3); // elements 2,3,4 std::cout << "Sum of subspan: " << sum(sub) << '\n'; } “` Output: “` Sum of vector: 15 Sum of array: 60 Sum of subspan: 9 “` ### 4. Working with Mutable Data `std::span` can be mutable or const. A mutable span allows element modification: “`cpp void double_values(std::span values) { for (int& v : values) v *= 2; } int main() { std::array data{1, 2, 3, 4}; double_values(data); // data now contains {2, 4, 6, 8} } “` ### 5. Common Pitfalls – **Dangling Spans** – Never keep a span after the underlying container is destroyed or resized beyond its original capacity. The span does not own the data. “`cpp std::span s; { std::vector temp{1, 2, 3}; s = temp; // OK } // temp is destroyed; s is now dangling “` – **Aliasing with Containers** – If you pass a span to a function that stores it beyond the scope of the caller, ensure the container outlives the span. – **Misusing Subspan** – `subspan(offset, count)` counts elements from the offset; an incorrect count can silently create an empty or partially overlapping view. ### 6. Advanced Usage: Constexpr and Compile‑Time Span `std::span` is `constexpr`‑friendly, enabling compile‑time manipulation of fixed arrays: “`cpp constexpr std::array nums{10, 20, 30, 40, 50}; constexpr std::span whole(nums); constexpr auto slice = whole.subspan(2); // {30, 40, 50} static_assert(slice.size() == 3); “` ### 7. When Not to Use std::span – **Non‑contiguous Data** – `std::span` is unsuitable for sparse or linked structures. – **Ownership Semantics** – If you need ownership transfer or deep copies, consider smart pointers or containers instead. – **Performance Critical Loops** – In extremely hot paths where even the two-word span might be a concern, manual pointers can sometimes be more efficient; however, profiling is essential. ### 8. Summary `std::span` brings a level of safety and clarity to C++ code by representing contiguous memory blocks in a self‑describing, lightweight form. It is ideal for generic algorithms, interoperation between APIs, and improving function signatures. While it is not a silver bullet—care must still be taken to avoid dangling references—the benefits in expressiveness and safety make `std::span` a staple in modern C++20 and beyond. Happy spanning!

In C++20, the introduction of concepts and constraints revolutionizes how developers write generic code. Concepts provide a declarative way to specify template requirements, improving readability, error messages, and compile-time checks. This article explores the core ideas behind concepts, demonstrates common patterns, and shows how to use constraints effectively in real-world scenarios.

What Are Concepts?

A concept is a compile-time predicate that can be applied to a type or a set of types. It is expressed as a bool-valued expression that depends on template parameters. For example:

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

Here, Integral is satisfied only by integral types (int, long, etc.). Concepts can also combine multiple requirements:

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

The requires clause lists expressions that must be valid for T. The trailing -> specifies the expected return type of each expression.

Using Concepts in Function Templates

Previously, we would rely on static_assert or SFINAE tricks to restrict template parameters. Concepts allow us to place constraints directly in the template parameter list:

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

If a type that does not satisfy Incrementable is passed, the compiler produces a clear diagnostic that the concept is not satisfied.

Example: A Generic Sort Function

template <typename RandomIt>
requires std::sortable <RandomIt>
void quick_sort(RandomIt first, RandomIt last) {
    if (first == last) return;
    auto pivot = *first;
    RandomIt left = first, right = last - 1;
    while (left < right) {
        while (*left <= pivot) ++left;
        while (*right > pivot) --right;
        if (left < right) std::iter_swap(left, right);
    }
    std::iter_swap(first, right);
    quick_sort(first, right);
    quick_sort(right + 1, last);
}

std::sortable is a standard concept that checks whether the iterator type can be sorted with operator<. If you try to call quick_sort with a container that doesn’t meet this requirement, the compiler will emit a concise error.

Constraints with requires Clauses

Constraints can also be applied to entire function bodies using requires expressions:

template <typename T>
void foo(T t)
    requires std::default_initializable <T> && std::copy_constructible<T>
{
    T a; // default-constructible
    T b = a; // copy-constructible
}

This syntax is useful when multiple templates or overloads share the same constraint logic but you want to keep the primary signature clean.

Practical Tips

1. Start with Built-in Concepts
   C++20 provides a set of standard concepts in `

   `: `std::integral`, `std::floating_point`, `std::default_initializable`, `std::sortable`, etc. Use them before writing custom ones.

2. Write Small, Reusable Concepts
   Break complex constraints into smaller concepts. For instance, separate Comparable and Swappable before combining them into a Sortable concept.

3. Document Concepts Clearly
   When you create a concept, add comments describing its intent. IDEs can display these comments as tooltips, improving maintainability.

4. Leverage requires Expressions for Overload Disambiguation
   Constraints can resolve ambiguity between overloaded templates by selecting the most constrained candidate.

5. Test with Edge Cases
   Compile your code with types that intentionally fail constraints to ensure diagnostic messages are informative.

Example: A Generic Hash Table

Below is a simplified hash table that uses concepts to enforce requirements on the key type:

#include <vector>
#include <string>
#include <iostream>
#include <concepts>
#include <functional>

template <typename K>
concept Hashable = requires(const K& k, std::size_t h) {
    { std::hash <K>{}(k) } -> std::convertible_to<std::size_t>;
};

template <Hashable K, typename V>
class HashTable {
public:
    HashTable(std::size_t sz = 16) : table(sz) {}

    void insert(const K& key, const V& value) {
        std::size_t idx = std::hash <K>{}(key) % table.size();
        table[idx].push_back({key, value});
    }

    V* find(const K& key) {
        std::size_t idx = std::hash <K>{}(key) % table.size();
        for (auto& [k, v] : table[idx]) {
            if (k == key) return &v;
        }
        return nullptr;
    }

private:
    std::vector<std::vector<std::pair<K, V>>> table;
};

int main() {
    HashTable<std::string, int> ht;
    ht.insert("foo", 42);
    if (auto p = ht.find("foo")) std::cout << *p << '\n';
}

Because the Hashable concept restricts K to types that can be hashed, any attempt to instantiate HashTable with an unsupported key type results in a compile-time error with a clear message.

Conclusion

Concepts and constraints bring a new level of clarity and safety to generic C++ programming. By defining precise, readable requirements, developers can catch errors early, improve compiler diagnostics, and write more expressive code. Embrace these features early in your projects to reap the benefits of modern C++ metaprogramming.

在C++20中，std::span被引入作为一个轻量级的、非拥有的数组视图。它在多种场景下极大地简化了代码，提高了可读性和安全性。本文将深入探讨std::span的核心特性、常见使用模式以及如何在已有项目中逐步迁移。

---

1. 何为 std::span

std::span 只保存了指向连续存储的指针和长度信息，它不拥有底层数据，也不负责内存管理。它的声明方式为：

template< class T, size_t Extent = dynamic_extent >
class span;

• T：元素类型
• Extent：大小，若为dynamic_extent（默认）则大小在运行时确定；若为常量，则在编译期固定。

---

2. 基本使用

2.1 创建

std::vector <int> vec{1,2,3,4,5};
std::span <int> s1(vec);                // 从容器创建
int arr[] = {10,20,30};
std::span <int> s2(arr);                // 从数组创建
std::span <int> s3{vec.data(), 3};       // 指定长度

2.2 访问

for (auto val : s1) std::cout << val << ' ';
std::cout << "\n";
std::cout << s1[2] << '\n';            // 访问
s1[2] = 99;                            // 修改

2.3 子视图

auto sub = s1.subspan(1, 3);           // 从索引1开始，长度3
auto tail = s1.last(2);                // 最后2个元素
auto head = s1.first(2);               // 前2个元素

---

3. 与容器的协同

3.1 作为参数

void process(std::span<const int> data) {
    for (int v : data) {
        // ...
    }
}

process(vec);    // 直接传递 vector
process(arr);    // 直接传递数组

3.2 与算法配合

std::sort(s1.begin(), s1.end());       // 使用标准算法

3.3 与字符串

std::string str = "Hello, world!";
std::span <char> span_str(str.data(), str.size());
span_str[0] = 'h';                     // 修改原字符串

---

4. 性能与安全

• 零成本：std::span 仅包含两个指针，编译器可以轻松优化为裸指针。
• 范围检查：span::at 提供边界检查，默认访问不检查。
• 不可变：使用 std::span<const T> 可以强制只读访问，避免意外修改。

---

5. 常见误区

1. 误认为拥有所有权
   span 并不管理内存，必须确保底层数据在使用期间有效。
2. 对齐与布局
   由于span不复制元素，使用时需保证底层容器连续布局（如std::vector、数组、std::array）。
3. 不适用于链表
   链表等非连续存储容器不能直接转换为span。

---

6. 逐步迁移示例

假设已有函数 void foo(int* data, size_t n)，可改为：

void foo(std::span <int> data) {
    // 现在可以使用更安全的接口
}

在调用点：

int arr[5] = {1,2,3,4,5};
foo(arr);               // 自动匹配
std::vector <int> v = {1,2,3};
foo(v);                 // 也能直接传递

---

7. 进阶：span 的扩展

• std::dynamic_extent：使用动态长度时的占位符。
• std::as_bytes 与 std::as_writable_bytes：将任意对象转换为字节视图。
• std::ranges::subrange：在C++23中与span兼容，提供更丰富的范围操作。

---

8. 结语

std::span 在C++20中以其简洁性与安全性为语言生态注入了新的活力。它不仅能让函数接口更具表达力，也能让代码在保持高性能的同时减少错误。无论是新项目还是维护已有代码，熟练掌握span都是提升代码质量的重要一步。

在现代 C++（C++11 及以后）中，线程安全的懒汉式单例实现可以利用函数静态变量的初始化特性。该特性保证了无论多少线程同时访问该函数，编译器都会保证静态对象只会被初始化一次，并且在多线程环境下的初始化过程是线程安全的。下面给出一个完整的实现示例，并对关键点进行详细说明。

// Singleton.hpp
#ifndef SINGLETON_HPP
#define SINGLETON_HPP

#include <iostream>
#include <string>

class Singleton {
public:
    // 删除拷贝构造函数和赋值运算符，防止多实例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 公开一个获取实例的静态成员函数
    static Singleton& instance() {
        static Singleton instance;   // 函数静态对象
        return instance;
    }

    // 示例业务函数
    void doSomething(const std::string& msg) {
        std::cout << "Singleton says: " << msg << std::endl;
    }

private:
    // 构造函数私有化，防止外部直接实例化
    Singleton() {
        std::cout << "Singleton constructed." << std::endl;
    }
    ~Singleton() {
        std::cout << "Singleton destructed." << std::endl;
    }
};

#endif // SINGLETON_HPP

// main.cpp
#include "Singleton.hpp"
#include <thread>
#include <vector>

void threadFunc(int id) {
    Singleton& s = Singleton::instance();
    s.doSomething("Hello from thread " + std::to_string(id));
}

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

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

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

    // 主线程也可以访问实例
    Singleton::instance().doSomething("Hello from main thread");

    return 0;
}

关键点说明

1. 函数静态对象
   static Singleton instance; 在 instance() 函数内定义。C++11 起，标准保证在多线程环境下该对象的初始化是互斥的，避免了“双重检查锁定（Double-Checked Locking）”的复杂实现。

2. 私有构造函数
   通过将构造函数私有化，阻止外部直接创建对象，确保所有访问都必须经过 instance() 函数。

3. 删除拷贝/赋值
   Singleton(const Singleton&) = delete; 与 Singleton& operator=(const Singleton&) = delete; 防止对象被复制或移动，保持单例唯一性。

4. 资源释放
   在程序结束时，函数静态对象会在 main() 结束后析构。若需要在程序运行期间主动销毁实例，可将单例包装在 std::unique_ptr 或使用 std::shared_ptr 并在需要时手动重置。

5. 可扩展性
   若单例需要依赖参数初始化，可使用 std::call_once 与 std::once_flag 或在第一次调用 instance() 时延迟构造。

性能与可维护性

• 延迟加载：首次调用 instance() 时才构造对象，减少启动时资源占用。
• 线程安全：标准保证，无需手动加锁，代码更简洁、错误更少。
• 可测试性：由于单例是全局可访问，可在单元测试中使用 Mock 对象替换，实现更好的可测试性。

---

进一步阅读

• 《Effective Modern C++》 – Scott Meyers，讨论 C++11 后的单例实现细节
• 《C++ Concurrency in Action》 – Anthony Williams，深入多线程与同步原语
• C++ 标准文档（ISO/IEC 14882:2017）第3.6.3节关于静态对象初始化的规范

通过以上实现，你可以在任何需要全局唯一实例的场景下安全、简洁地使用单例模式。

在现代 C++ 开发中，模板元编程（Template Metaprogramming, TMP）已经成为构建高性能、类型安全库的核心手段。尤其是在 C++17 之后，if constexpr、std::variant、constexpr 以及改进的折叠表达式等新特性，使得 TMP 既更易读也更易维护。本文将从实践角度出发，介绍几种常用的 TMP 技巧，并通过完整示例演示如何利用这些技巧实现一个可扩展的序列化框架。

1. 何为模板元编程

模板元编程是一种在编译期间通过模板实现计算的技术。与普通运行时编程不同，TMP 产生的代码会在编译阶段完成类型推断、循环展开、条件选择等，最终得到的可执行代码不含模板层次的运行时开销。

2. 关键技术点

2.1 if constexpr 与类型特性

C++17 引入 if constexpr，可以在编译期间根据类型特性决定执行路径。典型用法：

template<typename T>
void print(const T& value) {
    if constexpr (std::is_arithmetic_v <T>) {
        std::cout << value;
    } else {
        std::cout << value.toString();  // 假设非算术类型实现了 toString()
    }
}

2.2 折叠表达式

折叠表达式允许对参数包进行递归展开，常用于实现可变参数函数的编译期求和、乘积等。

template<typename... Args>
constexpr auto sum(Args... args) {
    return (args + ... + 0);   // 右折叠
}

2.3 std::variant 与访问器

std::variant 是一个类型安全的联合体，配合 std::visit 可以实现类型擦除的访问。与 TMP 结合，可在编译期决定不同类型的序列化实现。

using Value = std::variant<int, double, std::string>;

template<typename Visitor>
constexpr void visit_value(const Value& val, Visitor&& vis) {
    std::visit(std::forward <Visitor>(vis), val);
}

2.4 constexpr 计算

在 C++17 中，constexpr 函数可以包含循环、分支等语句，极大地提升编译期计算能力。通过 constexpr 计算常量表、查找表等，减少运行时开销。

3. 案例：类型安全的序列化框架

下面展示一个简易的序列化框架，支持整数、浮点数、字符串以及自定义类型。核心思路是：

1. 为每种可序列化类型实现 `Serializer ` 结构，提供 `to_json` 函数。
2. 利用 if constexpr 在 serialize 函数中根据 T 的特性决定调用哪种 `Serializer `。
3. 对于 std::variant，使用 std::visit 递归序列化其包含的任意类型。

#include <iostream>
#include <string>
#include <variant>
#include <vector>
#include <sstream>
#include <type_traits>

// 1. 基础序列化器
template<typename T, typename = void>
struct Serializer;   // 未定义的通用模板，供静态断言检查

// 整数
template<>
struct Serializer <int> {
    static std::string to_json(int v) { return std::to_string(v); }
};

// 浮点数
template<>
struct Serializer <double> {
    static std::string to_json(double v) {
        std::ostringstream ss;
        ss << v;
        return ss.str();
    }
};

// 字符串
template<>
struct Serializer<std::string> {
    static std::string to_json(const std::string& s) {
        return '"' + s + '"';
    }
};

// 向量（容器）
template<typename T>
struct Serializer<std::vector<T>> {
    static std::string to_json(const std::vector <T>& vec) {
        std::string res = "[";
        for (size_t i = 0; i < vec.size(); ++i) {
            res += Serializer <T>::to_json(vec[i]);
            if (i + 1 != vec.size()) res += ",";
        }
        res += "]";
        return res;
    }
};

// 自定义类型示例
struct Point {
    int x, y;
};

template<>
struct Serializer <Point> {
    static std::string to_json(const Point& p) {
        return "{\"x\":" + std::to_string(p.x) + ",\"y\":" + std::to_string(p.y) + "}";
    }
};

// 2. 统一接口
template<typename T>
std::string serialize(const T& value) {
    if constexpr (std::is_same_v<T, std::vector<int>> ||
                  std::is_same_v<T, std::vector<double>> ||
                  std::is_same_v<T, std::vector<std::string>> ||
                  std::is_same_v<T, std::vector<Point>>) {
        return Serializer <T>::to_json(value);
    } else {
        // 直接调用特化的 Serializer
        return Serializer <T>::to_json(value);
    }
}

// 3. 处理 std::variant
using Variant = std::variant<int, double, std::string, Point>;

template<typename Visitor>
std::string serialize_variant(const Variant& var, Visitor&& vis) {
    return std::visit(std::forward <Visitor>(vis), var);
}

int main() {
    std::vector <int> vec = {1, 2, 3};
    std::cout << serialize(vec) << '\n';

    Point p{10, 20};
    std::cout << serialize(p) << '\n';

    Variant v = std::string("hello");
    std::cout << serialize_variant(v, [](auto&& val) { return serialize(val); }) << '\n';
}

运行结果

[1,2,3]
{"x":10,"y":20}
"hello"

4. 性能与可维护性

• 编译期决定：所有序列化逻辑在编译时解析，运行时几乎无额外分支。
• 类型安全：Serializer 通过模板特化，若出现未支持的类型，编译器会报错，避免运行时错误。
• 可扩展：只需为新类型实现一个 `Serializer ` 特化，即可自动加入框架。

5. 小结

本文从实践出发，展示了 C++17 中 if constexpr、折叠表达式、std::variant 等新特性如何帮助我们编写更简洁、高效的模板元编程代码。通过一个类型安全的序列化框架案例，说明了 TMP 的实用价值与开发效率提升。未来，随着 C++23、C++26 等新标准的推出，模板元编程将更加直观、强大，值得每位 C++ 开发者持续关注与学习。

在现代C++编程中，智能指针是管理动态资源的核心工具。标准库提供了std::shared_ptr、std::unique_ptr和std::weak_ptr三种主要类型，每种都有其适用场景。若想在项目中自定义智能指针，尤其是需要支持弱引用的场景，必须仔细设计计数机制和线程安全。以下是一种实现思路，涵盖了核心概念、关键代码示例以及常见陷阱。

1. 基本思路

• 引用计数：使用一个单独的计数器对象（类似于std::shared_ptr的控制块）来记录强引用(strong_count)和弱引用(weak_count)。
• 控制块：在控制块中存放被管理对象的指针、strong_count、weak_count以及可选的自定义删除器。
• 构造与析构：MySharedPtr在构造时会增大strong_count，在析构时减小并在计数为0时销毁资源；MyWeakPtr仅操作weak_count，在释放时检查是否需要销毁控制块。
• 升级：MyWeakPtr::lock()尝试将弱引用升级为强引用，若资源已被释放则返回空指针。

2. 核心数据结构

template <typename T>
struct ControlBlock {
    T* ptr;                     // 被管理对象
    std::atomic <size_t> strong{1};  // 强引用计数
    std::atomic <size_t> weak{0};    // 弱引用计数
    std::function<void(T*)> deleter; // 可选自定义删除器

    ControlBlock(T* p, std::function<void(T*)> del = nullptr)
        : ptr(p), deleter(del) {}
};

使用std::atomic保证多线程环境下计数操作的原子性。若你确定在单线程中使用，可以直接用size_t。

3. MySharedPtr实现

template <typename T>
class MySharedPtr {
public:
    explicit MySharedPtr(T* p = nullptr)
        : ctrl(p ? new ControlBlock <T>(p) : nullptr) {}

    // 复制构造
    MySharedPtr(const MySharedPtr& other) noexcept
        : ctrl(other.ctrl) {
        if (ctrl) ctrl->strong.fetch_add(1, std::memory_order_relaxed);
    }

    // 移动构造
    MySharedPtr(MySharedPtr&& other) noexcept
        : ctrl(other.ctrl) {
        other.ctrl = nullptr;
    }

    ~MySharedPtr() {
        release();
    }

    MySharedPtr& operator=(const MySharedPtr& other) {
        if (this != &other) {
            release();
            ctrl = other.ctrl;
            if (ctrl) ctrl->strong.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

    T* operator->() const { return ctrl->ptr; }
    T& operator*() const { return *(ctrl->ptr); }
    explicit operator bool() const { return ctrl && ctrl->ptr; }

    size_t use_count() const {
        return ctrl ? ctrl->strong.load(std::memory_order_relaxed) : 0;
    }

private:
    ControlBlock <T>* ctrl;

    void release() {
        if (ctrl && ctrl->strong.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            // 资源释放
            if (ctrl->deleter)
                ctrl->deleter(ctrl->ptr);
            else
                delete ctrl->ptr;
            // 计数器已零，检查弱引用是否为零
            if (ctrl->weak.load(std::memory_order_acquire) == 0)
                delete ctrl;
        }
    }
};

4. MyWeakPtr实现

template <typename T>
class MyWeakPtr {
public:
    explicit MyWeakPtr(const MySharedPtr <T>& shared)
        : ctrl(shared.ctrl) {
        if (ctrl) ctrl->weak.fetch_add(1, std::memory_order_relaxed);
    }

    MyWeakPtr(const MyWeakPtr& other) noexcept
        : ctrl(other.ctrl) {
        if (ctrl) ctrl->weak.fetch_add(1, std::memory_order_relaxed);
    }

    MyWeakPtr(MyWeakPtr&& other) noexcept
        : ctrl(other.ctrl) {
        other.ctrl = nullptr;
    }

    ~MyWeakPtr() {
        release();
    }

    MyWeakPtr& operator=(const MyWeakPtr& other) {
        if (this != &other) {
            release();
            ctrl = other.ctrl;
            if (ctrl) ctrl->weak.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

    MySharedPtr <T> lock() const {
        if (ctrl && ctrl->strong.load(std::memory_order_acquire) > 0) {
            // 尝试提升计数
            ctrl->strong.fetch_add(1, std::memory_order_relaxed);
            return MySharedPtr <T>(ctrl);
        }
        return MySharedPtr <T>();
    }

    bool expired() const {
        return !ctrl || ctrl->strong.load(std::memory_order_acquire) == 0;
    }

private:
    ControlBlock <T>* ctrl;

    void release() {
        if (ctrl && ctrl->weak.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            if (ctrl->strong.load(std::memory_order_acquire) == 0)
                delete ctrl;
        }
    }
};

注意：MySharedPtr内部没有直接提供构造函数接受控制块的版本。可以添加私有构造函数供lock()使用，或使用友元实现。

5. 常见陷阱与最佳实践

1. 循环引用：MySharedPtr相互持有导致计数永不归零。使用MyWeakPtr打破循环。
2. 线程安全：计数器必须原子化；如果你还需要对ptr做读写同步，需进一步加锁或使用std::shared_mutex。
3. 自定义删除器：在构造MySharedPtr时传入std::function<void(T*)>，支持数组删除、资源回收池等。
4. 异常安全：所有操作在异常抛出前已确保计数正确更新。使用std::atomic的memory_order_acq_rel能保证原子操作的完整性。
5. 性能考虑：std::shared_ptr的实现已高度优化。自定义实现可根据需求裁剪，例如不需要弱引用就省略相关字段。
6. 内存泄漏：如果忘记删除控制块，可能导致内存泄漏。确保在计数为零时释放控制块。

6. 简单示例

int main() {
    MySharedPtr <int> sp1(new int(42));
    MyWeakPtr <int> wp(sp1);

    std::cout << "use_count: " << sp1.use_count() << '\n'; // 1

    if (auto sp2 = wp.lock()) {
        std::cout << "locked value: " << *sp2 << '\n';   // 42
        std::cout << "use_count after lock: " << sp2.use_count() << '\n'; // 2
    }

    sp1.~MySharedPtr(); // 手动析构
    std::cout << "expired? " << std::boolalpha << wp.expired() << '\n'; // true
}

通过上述实现，你可以获得一个与标准库功能相似但可自由扩展的自定义智能指针。根据项目需求，你可以进一步添加：

• 对齐/内存池支持
• 对象生命周期回调
• 兼容std::allocator的内存管理

以上即为在C++中实现自定义智能指针弱引用功能的完整思路与关键代码。祝你编码愉快！

在过去的几十年里，C++ 语言不断演进，从最初的过程式编程逐步迈向现代化的面向对象和泛型编程。随着 C++20 的推出，模块化成为了一个重要的新特性，旨在彻底解决传统头文件系统的弊端。本文将从理论、编译器实现、以及实际项目中的使用案例，逐步拆解 C++20 模块的核心概念与实践技巧。

---

1. 背景：头文件的痛点

传统的头文件（.h/.hpp）在 C++ 开发中扮演核心角色，但其设计缺陷在大型项目中逐渐显露：

痛点	典型表现	影响
重复编译	每个包含同一头文件的翻译单元都要完整编译	编译时间显著增加
隐式依赖	任何宏定义或类型定义变动都会导致大量文件重新编译	变更成本高
包含顺序	头文件间的依赖关系导致包含顺序敏感	易出错
维护成本	难以准确追踪某个符号的真实来源	代码库可维护性下降

C++20 通过模块（module）机制，首次在语言层面提供了显式、可编译的模块单元，打破了传统头文件所带来的多重编译和不确定依赖。

---

2. 模块基础概念

2.1 模块单元（Module Unit）

一个模块由若干模块单元组成，最常见的是主模块单元（export module）和分模块单元（module）。主模块单元负责声明和导出公共接口，而分模块单元用于实现内部细节。

// math.ixx  - 主模块单元
export module math;

export int add(int a, int b);
int mul(int a, int b); // 未导出

// math_impl.ixx  - 分模块单元
module math;

int mul(int a, int b) { return a * b; } // 实现内部细节

2.2 导出（Export）

export 关键字决定哪些符号可被外部模块引用。仅导出的符号才会在编译单元间暴露，其他则保持私有。

2.3 语义隔离

模块之间的关系是显式的，通过 import 引入。编译器可以在编译时识别模块边界，避免隐式包含。

import math; // 引入主模块
int main() {
    int c = add(1, 2); // 可用
}

---

3. 编译器支持与实现细节

3.1 编译顺序

模块编译分为两步：编译与链接。模块单元先被单独编译成 模块接口文件（.ifc），随后在使用模块的地方链接。

• g++ -fmodule-interface -fmodules-ts math.ixx -o math.ifc
• g++ -fmodule-file math.ifc -c main.cpp

这样可避免重复编译同一模块。

3.2 预编译模块缓存（PCM）

许多编译器（如 Clang、MSVC）会生成 预编译模块缓存，在第一次编译后将模块接口信息存入缓存，后续编译直接读取，从而进一步提升速度。

3.3 与旧头文件的兼容

模块支持隐式头文件导入（import "header.h";）以及将旧头文件视作模块单元，这使得迁移工作变得更加平滑。

---

4. 实战案例：构建一个简单的图形渲染引擎

假设我们正在开发一个小型渲染引擎 Renderer，需要处理 几何体、着色器和 纹理。下面演示如何用模块化结构化项目。

4.1 模块目录结构

renderer/
├─ math/
│  ├─ math.ixx
│  └─ math_impl.ixx
├─ geometry/
│  ├─ geometry.ixx
│  └─ geometry_impl.ixx
├─ shader/
│  ├─ shader.ixx
│  └─ shader_impl.ixx
├─ texture/
│  ├─ texture.ixx
│  └─ texture_impl.ixx
└─ main.cpp

4.2 math 模块（核心数学）

// math.ixx
export module math;

export struct Vec3 { float x, y, z; };
export Vec3 operator+(Vec3 a, Vec3 b);
export Vec3 normalize(Vec3 v);

4.3 geometry 模块

// geometry.ixx
export module geometry;
import math;

export struct Vertex { math::Vec3 pos; };
export struct Mesh { std::vector <Vertex> vertices; };

4.4 shader 模块

// shader.ixx
export module shader;
export void compile_shader(const std::string& src);

4.5 texture 模块

// texture.ixx
export module texture;
export struct Texture { int width, height; };

4.6 main.cpp

import geometry;
import shader;
import texture;

int main() {
    geometry::Mesh mesh{{{0,0,0}, {1,0,0}, {0,1,0}}};
    shader::compile_shader("void main() {}");
    texture::Texture tex{1024, 768};
    // ...
}

通过上述组织，每个模块只关心自己的内部实现，接口导出清晰，编译时能显著减少重编译次数。

---

5. 性能评估

在一项内部基准测试中，将传统头文件系统迁移至模块化后，编译时间平均下降：

项目	编译时间（秒）	变更文件	重编译单元
头文件	45	30	30
模块化	20	30	5

尤其在多文件大项目中，模块化的优势更加显著。

---

6. 迁移策略

1. 逐模块分离：从现有头文件逐步拆分为模块单元，先把核心库拆成单个模块。
2. 使用导入：将旧 #include 替换为 import，并在需要时保留旧头文件作为兼容模块。
3. 构建脚本：更新 Makefile/CMake，以支持 .ixx 编译器选项 -fmodule-interface。
4. 测试：通过单元测试确保功能一致，模块化后编译单元之间的接口稳定。

---

7. 未来展望

• 模块化标准化：C++23 将进一步完善模块系统，加入 预编译模块缓存 的标准化机制。
• 跨语言互操作：借助模块，C++ 与 Rust、Go 等语言的互操作将变得更直观。
• 持续集成优化：CI 系统可根据模块依赖关系只重新编译受影响的模块，提高构建效率。

---

结语

C++20 模块不仅解决了头文件的长期痛点，更为现代 C++ 开发提供了更高的抽象与编译效率。虽然迁移成本不可忽视，但从长期维护与性能角度来看，模块化是值得投入的技术升级。希望本文能为你在项目中落地 C++20 模块化提供实用的思路与参考。

在 C++ 中处理多种类型的值时，最常见的做法之一是使用 union。虽然 union 在底层非常高效，但它也带来了许多潜在风险，尤其是在面向对象编程和现代 C++ 开发环境中。随着 C++17 标准的推出，std::variant 成为一种更安全、更易用的替代方案。本文将深入探讨为什么在现代 C++ 项目中应该优先考虑 std::variant，而不是传统的 union。

1. 传统 union 的局限与风险

1.1 缺乏类型安全

union MyUnion {
    int i;
    double d;
};

使用 union 时，程序员必须手动跟踪当前激活的成员。若忘记更新，读取错误的成员会导致未定义行为（UB）。例如：

MyUnion u;
u.i = 42;
std::cout << u.d << '\n';  // UB: 访问未激活成员

1.2 需要手动管理构造与析构

如果 union 中包含非平凡类型（例如 std::string、std::vector），必须手动调用构造函数与析构函数，并使用 placement new。错误的生命周期管理同样会导致 UB 或内存泄漏。

union MyComplex {
    std::string s;
    int n;
};
MyComplex u;
new (&u.s) std::string("hello");  // 必须手动析构
u.s.~basic_string();              // 手动析构

1.3 与现代特性不兼容

union 在 C++ 中与 RTTI、模板元编程、constexpr 等现代特性配合使用会更麻烦。比如，在 constexpr 上下文中，使用 union 是不可行的。

2. std::variant 的优势

2.1 运行时类型安全

std::variant 内部维护一个索引，指明当前活跃的类型。`std::get

()` 或 `std::get_if()` 在访问不匹配的类型时会抛出 `std::bad_variant_access`（或者返回空指针），避免了隐式错误。 “`cpp std::variant v; v = 10; try { std::cout << std::get(v) << '\n'; // 抛出异常 } catch (const std::bad_variant_access&) { std::cout << "Wrong type\n"; } “` ### 2.2 自动生命周期管理 std::variant 自动调用构造和析构，无需手动管理。对于任何类型，它都能正确处理。 “`cpp std::variant<std::string, std::vector> v = std::string(“Hello”); v = std::vector {1, 2, 3}; // 自动析构前一个 std::string “` ### 2.3 constexpr 友好 C++17 之后，std::variant 成为 constexpr 容器，允许在编译期使用。例如： “`cpp constexpr std::variant cv = 42; static_assert(std::get (cv) == 42, “constexpr works”); “` ### 2.4 兼容 std::visit 与 std::apply std::variant 与 std::visit 组合提供了类似模式匹配的语义，代码更简洁： “`cpp std::visit([](auto&& arg){ std::cout << arg < **Tip**：在迁移已有代码时，考虑使用 `std::variant` 替换 `union`，并配合 `std::visit` 或 `if constexpr` 进行模式匹配，逐步提升项目的安全性和现代化程度。

std::variant has been part of C++17 and is a powerful tool that brings the flexibility of a union with the safety guarantees of a type‑safe discriminated union. It allows a single variable to hold one of several specified types, while guaranteeing that only one is active at a time and that you cannot inadvertently read the wrong type. In this article we’ll explore the practical use‑cases, common pitfalls, and advanced tricks that make std::variant a go‑to component in modern C++ codebases.

Why replace std::variant with a union?

• Safety – std::variant maintains a discriminant internally. If you try to access the wrong type, it throws an exception (std::bad_variant_access). A raw union, on the other hand, will simply produce garbage or invoke undefined behaviour.
• Constructors & Destructors – It correctly constructs and destructs the active member, calling the right constructors, destructors, and copy/move operations.
• Value semantics – std::variant behaves like a regular value type: copyable, movable, assignable, and comparable (if all alternatives are comparable).
• Type introspection – You can query the type held by a variant at compile time (std::variant_alternative_t) or at runtime (std::holds_alternative / std::get_if).

Basic usage

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

using Value = std::variant<int, double, std::string>;

int main() {
    Value v = 42;            // holds an int
    std::visit([](auto&& x) { std::cout << x << '\n'; }, v);

    v = 3.14;                // now holds a double
    std::visit([](auto&& x) { std::cout << x << '\n'; }, v);

    v = std::string{"hello"}; // holds a string
    std::visit([](auto&& x) { std::cout << x << '\n'; }, v);
}

The std::visit function dispatches a visitor to the active alternative. The visitor can be a lambda or a functor; the compiler deduces the type for each alternative.

Visiting with overloaded lambdas

A common pattern is to use a helper overloaded struct to combine multiple lambdas:

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

Value v = std::string{"example"};

std::visit(overloaded{
    [](int i) { std::cout << "int: " << i; },
    [](double d) { std::cout << "double: " << d; },
    [](const std::string& s) { std::cout << "string: " << s; }
}, v);

This eliminates the need for manual if constexpr chains and keeps the visitor succinct.

Checking the active type

You can test which type the variant currently holds:

if (std::holds_alternative <int>(v)) {
    std::cout << "int: " << std::get<int>(v) << '\n';
} else if (std::holds_alternative <double>(v)) {
    std::cout << "double: " << std::get<double>(v) << '\n';
} else {
    std::cout << "string: " << std::get<std::string>(v) << '\n';
}

Alternatively, you can retrieve the index with v.index() where the index corresponds to the order of types in the template parameter pack.

Common pitfalls

1. Copying from an empty variant
   A default‑constructed std::variant holds the first alternative by default. Trying to access it before setting a value may give you an unexpected default. Use std::variant::valueless_by_exception() to detect if an exception during assignment left the variant in a valueless state.

2. Returning a std::variant from a function
   Ensure that all alternative types are either copy‑constructible or move‑constructible, because the returned variant will be moved or copied by the caller.

3. Exception safety
   If an exception is thrown while constructing the new alternative, the variant remains in the previous state. If constructing the new alternative itself throws, the variant becomes valueless_by_exception. Handling this scenario gracefully is key for robust code.

Advanced techniques

1. Type‑safe arithmetic with std::variant

Value add(const Value& a, const Value& b) {
    return std::visit([](auto&& x, auto&& y) {
        using T1 = std::decay_t<decltype(x)>;
        using T2 = std::decay_t<decltype(y)>;
        if constexpr (std::is_arithmetic_v <T1> && std::is_arithmetic_v<T2>) {
            return Value(x + y); // implicit promotion rules apply
        } else {
            throw std::logic_error("Unsupported types for addition");
        }
    }, a, b);
}

2. std::variant as a small object for visitor pattern

In event‑driven systems, std::variant can replace the classic visitor pattern:

struct MouseEvent { /* ... */ };
struct KeyboardEvent { /* ... */ };
struct ResizeEvent { /* ... */ };

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

void dispatch(Event e) {
    std::visit(overloaded{
        [](MouseEvent const& m) { handleMouse(m); },
        [](KeyboardEvent const& k) { handleKeyboard(k); },
        [](ResizeEvent const& r) { handleResize(r); }
    }, e);
}

This removes the need for virtual inheritance and keeps all event types in a single type‑safe container.

3. Combining with std::optional

If you need a “nullable variant” you can wrap it in std::optional:

std::optional <Value> maybeVal = std::nullopt; // empty

// Later assign a value
maybeVal = 5;

if (maybeVal) {
    std::visit(/* visitor */, *maybeVal);
}

Alternatively, use std::variant<std::monostate, int, double, std::string> to encode an empty state inside the variant itself.

Performance considerations

• Size – The size of a std::variant is the maximum size of its alternatives plus the size of the discriminant. For small types (e.g., primitives) this overhead is negligible.
• Alignment – std::variant guarantees proper alignment for all alternatives.
• Copy/move costs – If you have a variant with expensive alternatives, each copy/move may copy the currently active alternative. Be mindful of copy elision and move semantics.
• Branching – The visitor dispatch incurs a virtual‑like dispatch at runtime. For high‑performance code, you might want to keep the alternative set small or unroll the visitor manually.

Real‑world example: JSON values

A lightweight JSON representation often uses a variant:

struct Json; // forward declaration

using JsonValue = std::variant<
    std::nullptr_t,
    bool,
    int64_t,
    double,
    std::string,
    std::vector <Json>,
    std::map<std::string, Json>
>;

struct Json {
    JsonValue value;
};

You can then write parsers and serializers that operate on Json without resorting to dynamic casts or a hand‑rolled type system.

Conclusion

std::variant is a versatile and type‑safe alternative to union, std::any, or dynamic polymorphism. It gives you compile‑time guarantees, clean syntax, and robust runtime behaviour. By mastering visitors, type checks, and the nuances of exception safety, you can use std::variant to build safer, more maintainable C++ codebases.

Happy coding, and may your variants always hold the correct type!

======================================================

Coroutines were long a feature of the C++ language that developers had to chase through workarounds and external libraries. With C++20, the standard finally provides first‑class support, giving us a clean syntax, well‑defined lifetimes, and a set of awaitable types that can be composed freely. In this article we’ll walk through the core concepts, show how to write a simple generator, explore std::generator, and discuss how coroutines can simplify asynchronous I/O, lazy evaluation, and stateful computations.

1. The Core Idea

A coroutine is a function that can suspend its execution and later resume from the same point. Think of it as a lightweight cooperative thread that can pause at designated points (co_await, co_yield, or co_return) and preserve its stack and local state. The compiler transforms the coroutine into a state machine under the hood; the programmer simply writes a natural, sequential style of code.

The primary language constructs introduced for coroutines are:

Keyword	Purpose
co_await	Suspend until an awaitable yields control.
co_yield	Suspend and produce a value to the caller (generators).
co_return	Finish the coroutine, optionally returning a value.

2. The Awaitable Interface

A type can be awaited if it satisfies the awaitable protocol. The standard defines this protocol in terms of three member functions:

bool await_ready();      // Is the operation ready immediately?
void await_suspend(std::coroutine_handle<>) ; // Called if not ready
T   await_resume();      // Result after resumption

The compiler calls these in the order:

1. await_ready() – if true, the coroutine continues without suspension.
2. await_suspend(handle) – may suspend the coroutine. It may also resume it immediately.
3. await_resume() – obtains the result when the coroutine resumes.

3. A Minimal Coroutine: my_async_task

Below is a minimal awaitable that simulates an asynchronous operation using std::this_thread::sleep_for. It demonstrates how to wrap a blocking operation in a coroutine-friendly interface:

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

struct my_async_task {
    struct promise_type {
        my_async_task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

my_async_task async_sleep(std::chrono::milliseconds ms) {
    std::cout << "Sleeping for " << ms.count() << " ms\n";
    std::this_thread::sleep_for(ms);
    co_return;
}

Using this:

int main() {
    async_sleep(std::chrono::milliseconds(500));
}

Even though the coroutine never suspends, the example shows how the promise_type controls the coroutine’s lifecycle.

4. Generators with std::generator

C++20 introduced `std::generator

`, a standard awaitable that behaves like a lazy sequence. Under the hood, it implements the coroutine protocol with `co_yield`. Here’s a classic Fibonacci generator: “`cpp #include #include std::generator fib(int n) { int a = 0, b = 1; for (int i = 0; i < n; ++i) { co_yield a; std::tie(a, b) = std::make_pair(b, a + b); } } “` Consuming it: “`cpp int main() { for (int value : fib(10)) { std::cout << value << ' '; } std::cout << '\n'; } “` Output: “` 0 1 1 2 3 5 8 13 21 34 “` The generator lazily computes values on each iteration, making it memory efficient and ideal for streaming data. ### 5. Async I/O with `co_await` and `std::future` While `std::generator` handles synchronous iteration, asynchronous I/O typically uses `std::future` or custom awaitables. For example, with `std::future`, you can await a background computation: “`cpp #include #include int heavy_computation() { std::this_thread::sleep_for(std::chrono::seconds(2)); return 42; } std::future run_async() { return std::async(std::launch::async, heavy_computation); } int main() { auto fut = run_async(); std::cout << "Waiting for result…\n"; int result = fut.get(); // Blocks until ready std::cout << "Result: " << result << '\n'; } “` To make this coroutine-friendly, wrap the future in an awaitable: “`cpp struct future_awaiter { std::future & fut; bool await_ready() { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; } void await_suspend(std::coroutine_handle h) { std::thread([h, &fut]() { fut.wait(); h.resume(); }).detach(); } int await_resume() { return fut.get(); } }; future_awaiter co_await_future(std::future & fut) { return {fut}; } auto async_wrapper() -> std::generator { std::future fut = run_async(); int value = co_await co_await_future(fut); co_yield value; } “` Now the coroutine suspends until the async operation completes, resuming seamlessly. ### 6. Practical Use Cases | Scenario | Coroutine Benefit | Example | |———-|——————-|———| | **Lazy Streams** | No materialization of entire data set | `std::generator` for file lines, sensor data | | **Async I/O** | Non-blocking suspension, simpler flow | `co_await` with sockets or `std::future` | | **State Machines** | Encapsulate complex state transitions | Game AI behaviors, protocol handlers | | **Undo/Redo** | Store snapshots lazily | Co-routines that capture state on demand | | **Reactive Programming** | Combine streams easily | `co_yield` to produce UI events | ### 7. Pitfalls & Best Practices 1. **Avoid Blocking in Coroutines**: A coroutine that blocks the thread (e.g., `std::this_thread::sleep_for`) defeats the purpose of asynchrony. Use awaitables that yield control. 2. **Lifetime Management**: The coroutine’s promise object lives until the coroutine completes. Be careful with captures; use `std::move` for expensive resources. 3. **Exception Safety**: `unhandled_exception` in the promise should be defined. Prefer `std::terminate()` or propagate the exception. 4. **Stack Size**: Coroutines preserve local variables but not the call stack; however, deep recursion can still exhaust the stack if not careful. 5. **Deterministic Destruction**: Resources that need deterministic cleanup must be wrapped in a `std::unique_ptr` or a custom `finally` pattern inside the coroutine. ### 8. Conclusion C++20’s coroutine support opens a new paradigm for writing asynchronous, lazy, and stateful code. By turning the language itself into a cooperative concurrency primitive, developers can express complex flows in a clean, linear style. Whether you’re building a high‑performance network server, a lazy data pipeline, or a responsive UI, coroutines provide a powerful toolset that integrates seamlessly with the rest of the language. Dive in, experiment with generators and awaitables, and let the compiler do the heavy lifting while you keep the code readable.