C++26 - 下一个里程碑

C++26：仍在标准化中的下一个里程碑

C++26 已于 2025 年年中完成特性冻结（feature freeze），预计 2026 年正式发布。它继续强化元编程、安全性、并发和标准库表达能力。

静态反射（Static Reflection）

C++26 引入了编译期静态反射，可以查询类型、成员、枚举等元信息。

#include <meta>
#include <string_view>

// 枚举转字符串
template <typename E>
constexpr std::string_view enum_to_string(E value)
    requires std::is_enum_v<E>
{
    template for (constexpr auto e : std::meta::enumerators_of(^^E)) {
        if (value == [:e:]) {
            return std::meta::identifier_of(e);
        }
    }
    return "<unknown>";
}

enum class Color { Red, Green, Blue };

static_assert(enum_to_string(Color::Red) == "Red");

契约（Contracts）

契约式编程原生化，支持前置条件、后置条件和断言。

int divide(int a, int b)
    pre(a >= 0)           // 前置条件：a 必须非负
    pre(b != 0)           // 前置条件：b 不能为 0
    post(r: r >= 0)       // 后置条件：结果非负
{
    contract_assert(a < 1000);  // 断言
    return a / b;
}

Pack Indexing

直接通过下标访问参数包，无需递归展开。

// 获取参数包的第 i 个类型/值
template <typename... Ts>
using first_t = Ts...[0];

template <typename... Ts>
constexpr std::size_t count = sizeof...(Ts);

template <auto... Values>
constexpr auto first_value = Values...[0];

static_assert(std::is_same_v<first_t<int, double, char>, int>);
static_assert(first_value<1, 2, 3> == 1);

`= delete("reason")`

删除函数时可以附带诊断信息。

struct Handle {
    Handle(const Handle&) = delete("Handle 不可复制");
    Handle& operator=(const Handle&) = delete("Handle 不可赋值");
};

// Handle h2 = h1;  // 编译错误：Handle 不可复制

结构化绑定改进

C++26 允许在结构化绑定中使用属性和 _ 占位符。

std::pair<int, int> p{1, 2};

[[nodiscard]] auto [x, _] = p;  // 忽略第二个元素
// x = 1

std::map<int, std::string> m;
if (auto [it, ok] = m.insert({1, "one"}); ok) {
    // 在 if 条件中使用结构化绑定（C++26 进一步放宽）
}

`std::execution` / Sender-Receiver

标准库引入统一的异步执行模型。

#include <execution>
#include <iostream>

namespace ex = std::execution;

int main() {
    // 构造一个发送器链：产生 42，然后打印
    auto snd = ex::just(42)
             | ex::then([](int v) { std::cout << v << "\n"; });

    // 同步等待完成
    ex::sync_wait(std::move(snd));
}

`std::simd`

标准 SIMD 类型，便于数据并行计算。

#include <simd>

float data1[] = {1.0f, 2.0f, 3.0f, 4.0f};
float data2[] = {5.0f, 6.0f, 7.0f, 8.0f};
std::simd<float> a(data1, std::element_aligned);  // 从内存加载
std::simd<float> b(data2, std::element_aligned);
std::simd<float> c = a + b;  // 向量化加法

std::cout << c[0] << "\n";  // 6

`views::concat`

将多个范围连接成一个视图。

#include <ranges>
#include <vector>
#include <list>

std::vector<int> v{1, 2, 3};
std::list<int> l{4, 5, 6};

for (int x : std::views::concat(v, l)) {
    std::cout << x << " ";  // 1 2 3 4 5 6
}

`std::span::at`

带边界检查的 span 元素访问。

#include <span>

int arr[] = {10, 20, 30};
std::span<int> s{arr};

std::cout << s.at(0) << "\n";  // 10
// s.at(10);  // 抛出 std::out_of_range

饱和算术（Saturation Arithmetic）

溢出时进行钳位，而不是回绕。

#include <numeric>

unsigned char a = 200;
unsigned char b = 100;
auto c = std::add_sat(a, b);  // 255（饱和到最大值）
auto d = std::sub_sat(a, b);  // 100

`std::breakpoint`

标准调试断点支持。

#include <debugging>

void inspect(int value) {
    if (value < 0) {
        std::breakpoint();  // 调试器在此处中断
    }
}

// 仅在调试器附加时才中断
std::breakpoint_if_debugging();

Hazard Pointers

无锁并发中安全回收对象的机制。

#include <hazard_pointer>

struct Node {
    int value;
    std::atomic<Node*> next;
};

std::atomic<Node*> head;

Node* read() {
    std::hazard_pointer hp = std::make_hazard_pointer();
    Node* curr = hp.protect(head);  // 原子加载并保护当前值
    // 使用 curr 期间对象不会被回收
    return curr;
}

User-space RCU

用户空间读-拷贝-更新机制，适合读多写少场景。

#include <rcu>

struct Node : std::rcu_obj_base<Node> {
    int value;
    std::atomic<Node*> next;
};

std::atomic<Node*> global_ptr;

// 读者
void reader() {
    std::rcu_reader guard;
    Node* p = global_ptr.load(std::memory_order_acquire);
    // 在 guard 生命周期内安全读取 p
}

// 写者
void writer(Node* new_node) {
    Node* old = global_ptr.exchange(new_node, std::memory_order_acq_rel);
    old->retire();  // 异步、安全地回收旧节点
}