C++26静态反射与契约编程：现代C++新特性解析

1. C++26静态反射：元编程的终极进化

静态反射（Static Reflection）无疑是C++26最具革命性的特性。作为一名长期奋战在C++一线的开发者，我第一次看到这个特性时，内心是震撼的——它彻底改变了我们处理元编程的方式。传统C++模板元编程就像在黑暗房间里摸索，而静态反射则像打开了电灯开关。

1.1 反射运算符与拼接运算符

静态反射的核心在于两个新运算符：

• ^T（反射运算符）：获取类型T的元数据描述符
• [:e:]（拼接运算符）：将反射值转换回实际代码元素

这两个运算符配合使用，可以在编译期完成类型自省和代码生成。让我们看一个实际案例：

cpp复制#include <meta>
#include <string>
#include <vector>

template <typename T>
void inspect_type() {
    constexpr auto type_info = ^T;
    
    std::println("Type name: {}", std::meta::name_of(type_info));
    std::println("Size: {} bytes", sizeof(T));
    std::println("Alignment: {}", alignof(T));
    
    if constexpr (std::meta::is_class(type_info)) {
        std::println("\nMembers:");
        template for (constexpr auto member : std::meta::nonstatic_data_members_of(type_info)) {
            std::println("- {}: {} (offset: {})", 
                std::meta::name_of(member),
                std::meta::type_of(member),
                std::meta::offset_of(member));
        }
    }
}

struct Point {
    float x;
    float y;
    std::string label;
};

int main() {
    inspect_type<Point>();
    /* 输出：
    Type name: Point
    Size: 40 bytes
    Alignment: 8

    Members:
    - x: float (offset: 0)
    - y: float (offset: 4)
    - label: std::string (offset: 8)
    */
}

1.2 实战：自动序列化框架

静态反射最激动人心的应用之一是自动序列化。过去我们需要手动为每个类编写序列化代码，现在可以完全自动化：

cpp复制#include <meta>
#include <json.hpp> // 假设有JSON库

template <typename T>
nlohmann::json to_json(const T& obj) {
    nlohmann::json j;
    
    template for (constexpr auto member : std::meta::nonstatic_data_members_of(^T)) {
        const auto& value = obj.[:member:];
        j[std::meta::name_of(member)] = to_json_value(value);
    }
    
    return j;
}

// 递归处理各种类型
template <typename U>
auto to_json_value(const U& val) {
    if constexpr (std::meta::is_class(^U)) {
        return to_json(val); // 递归处理嵌套对象
    } else if constexpr (std::is_arithmetic_v<U>) {
        return val;
    } else if constexpr (std::is_same_v<U, std::string>) {
        return val;
    } else if constexpr (requires { val.begin(); val.end(); }) {
        nlohmann::json arr = nlohmann::json::array();
        for (const auto& item : val) {
            arr.push_back(to_json_value(item));
        }
        return arr;
    }
}

struct Person {
    std::string name;
    int age;
    std::vector<std::string> hobbies;
    Point location;
};

int main() {
    Person p{"Alice", 30, {"reading", "hiking"}, {1.5f, 2.3f, "home"}};
    auto json = to_json(p);
    std::cout << json.dump(2) << std::endl;
}

这个自动序列化框架具有以下优势：

1. 零运行时开销：所有反射操作在编译期完成
2. 类型安全：编译期检查确保所有成员都被正确处理
3. 可扩展性：新增成员无需修改序列化代码
4. 递归处理：自动处理嵌套对象和容器

1.3 编译器支持现状与迁移建议

目前主要编译器的支持情况：

迁移建议：

1. 从枚举字符串化开始尝试，这是最直观的应用场景
2. 逐步替换现有的代码生成工具（如protobuf、thrift的代码生成器）
3. 谨慎评估性能关键路径，确保反射不会引入不必要的编译时间增加

注意事项：静态反射目前仍处于标准化过程中，某些语法细节可能在最终发布前调整。建议在项目中使用时做好版本隔离。

2. 契约编程：从防御性编程到确定性设计

契约（Contracts）是C++26引入的另一个重磅特性，它从根本上改变了我们编写健壮代码的方式。作为一名经历过无数深夜调试崩溃问题的开发者，我可以说契约是近年来最令我兴奋的特性之一。

2.1 契约语法详解

C++26引入了三种契约属性：

1. [[pre: condition]]：前置条件，函数执行前必须满足
2. [[post: condition]]：后置条件，函数返回时必须满足
3. [[post r: condition]]：特殊后置条件，r代表返回值

让我们看一个银行账户的示例：

cpp复制#include <contracts>
#include <stdexcept>

class BankAccount {
    double balance_ = 0.0;
    
    // 类不变式：余额不能为负
    [[assert: balance_ >= 0.0]] 
    void check_invariant() const {}
    
public:
    void deposit(double amount)
        [[pre: amount > 0.0]]               // 存款必须为正数
        [[post: balance_ == old(balance_) + amount]]  // 余额正确增加
    {
        balance_ += amount;
        check_invariant();
    }
    
    void withdraw(double amount)
        [[pre: amount > 0.0]]               // 取款必须为正数
        [[pre: amount <= balance_]]         // 余额必须足够
        [[post: balance_ == old(balance_) - amount]]  // 余额正确减少
    {
        balance_ -= amount;
        check_invariant();
    }
    
    [[nodiscard]] double get_balance() const noexcept {
        check_invariant();
        return balance_;
    }
};

2.2 契约语义与构建配置

C++26定义了四种契约语义，可以通过编译选项或代码属性控制：

在实际项目中，我推荐这样的配置策略：

cmake复制if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    target_compile_options(my_target PRIVATE -fcontracts=observe)
else()
    target_compile_options(my_target PRIVATE -fcontracts=quick_enforce)
endif()

2.3 契约与异常处理的配合

契约不应该替代异常处理，而是与之互补。好的实践是：

cpp复制#include <contracts>
#include <stdexcept>

class Vector {
    int* data_;
    size_t size_;
    size_t capacity_;
    
public:
    int& at(size_t index)
        [[pre: index < size_]]  // 契约检查边界
    {
        try {
            return data_[index];
        } catch (...) {
            // 处理内存访问错误等意外情况
            throw std::runtime_error("Vector access failed");
        }
    }
    
    // ... 其他成员函数
};

这种组合的优势在于：

1. 契约处理明确的、可预测的错误条件
2. 异常处理意外的、不可预测的错误情况
3. 代码职责清晰，可读性高

2.4 契约的性能考量

在性能关键代码中，契约可能会带来开销。这时可以考虑以下优化策略：

1. 对性能极其敏感的代码路径，使用ignore语义
2. 将多个相关检查合并为一个复合条件
3. 在调试版本中使用详细检查，发布版本中使用最小检查

cpp复制void process_data(int* data, size_t size)
    [[pre: data != nullptr]]
    [[pre: size > 0 && size < MAX_SIZE]]
{
    // 性能关键部分
    [[using contract: ignore]] {
        for (size_t i = 0; i < size; ++i) {
            data[i] = transform(data[i]);
        }
    }
}

经验分享：在实际项目中引入契约时，建议先从新代码开始，逐步改造旧代码。一次性全面引入可能会导致大量契约违例难以处理。

3. std::execution：异步编程的新范式

C++26的std::execution（Sender/Receiver模型）解决了C++长期以来缺乏统一异步编程模型的问题。作为一名经历过回调地狱、future/promise和协程各种异步方案的开发者，我认为这是C++并发编程的重大进步。

3.1 核心概念解析

Sender/Receiver模型基于三个核心抽象：

1. Scheduler（调度器）：执行上下文，如线程池、GPU队列等
2. Sender（发送器）：描述异步工作单元
3. Receiver（接收器）：消费异步结果

这种模型的强大之处在于其组合性。让我们看一个实际例子：

cpp复制#include <execution>
#include <iostream>
#include <thread>

int main() {
    // 获取默认调度器（通常是线程池）
    auto sch = std::execution::get_scheduler();
    
    // 创建异步任务链
    auto task = std::execution::schedule(sch)                      // 1. 在调度器上安排
             | std::execution::then([] {                           // 2. 第一个异步任务
                   std::cout << "Task 1 on thread: " 
                             << std::this_thread::get_id() << "\n";
                   return 42;
               })
             | std::execution::then([](int x) {                    // 3. 第二个任务（接续）
                   std::cout << "Got value: " << x << "\n";
                   return x * 2;
               })
             | std::execution::upon_error([](std::exception_ptr e) { // 4. 错误处理
                   try { std::rethrow_exception(e); }
                   catch (const std::exception& ex) {
                       std::cerr << "Error: " << ex.what() << "\n";
                   }
               });
    
    // 同步等待任务完成
    auto result = std::execution::sync_wait(task);
    std::cout << "Final result: " << *result << "\n";
}

3.2 与现有异步方案的对比

让我们将std::execution与传统方案进行比较：

3.3 实际应用：并行数据处理

std::execution特别适合数据并行处理。下面是一个并行图像处理的例子：

cpp复制#include <execution>
#include <vector>
#include <algorithm>
#include <span>

struct Image {
    std::vector<float> pixels;
    int width;
    int height;
    
    Image(int w, int h) : width(w), height(h), pixels(w * h) {}
};

void process_image(Image& img) {
    auto scheduler = std::execution::get_parallel_scheduler();
    
    // 将图像分块处理
    constexpr int tile_size = 16;
    int tiles_x = (img.width + tile_size - 1) / tile_size;
    int tiles_y = (img.height + tile_size - 1) / tile_size;
    
    auto process_tile = [&img](int tx, int ty) {
        int x_start = tx * tile_size;
        int y_start = ty * tile_size;
        int x_end = std::min(x_start + tile_size, img.width);
        int y_end = std::min(y_start + tile_size, img.height);
        
        for (int y = y_start; y < y_end; ++y) {
            for (int x = x_start; x < x_end; ++x) {
                // 应用图像处理算法
                img.pixels[y * img.width + x] = 
                    std::clamp(img.pixels[y * img.width + x] * 1.5f, 0.0f, 1.0f);
            }
        }
    };
    
    // 创建并行任务
    auto task = std::execution::transfer_just(scheduler, std::ref(img))
             | std::execution::bulk(tiles_x * tiles_y, 
                   [=](int idx, Image& img) {
                       int tx = idx % tiles_x;
                       int ty = idx / tiles_x;
                       process_tile(tx, ty);
                   });
    
    std::execution::sync_wait(task);
}

3.4 高级特性：自定义调度器

std::execution的强大之处在于可以自定义调度器。例如，创建一个优先级的线程池：

cpp复制#include <execution>
#include <queue>
#include <mutex>
#include <condition_variable>

class PriorityThreadPool {
    struct Task {
        int priority;
        std::function<void()> work;
        
        bool operator<(const Task& other) const {
            return priority < other.priority;
        }
    };
    
    std::priority_queue<Task> tasks_;
    std::vector<std::jthread> workers_;
    std::mutex mutex_;
    std::condition_variable cv_;
    bool stop_ = false;
    
public:
    explicit PriorityThreadPool(size_t threads = std::thread::hardware_concurrency()) {
        for (size_t i = 0; i < threads; ++i) {
            workers_.emplace_back([this] { worker_loop(); });
        }
    }
    
    ~PriorityThreadPool() {
        {
            std::lock_guard lock(mutex_);
            stop_ = true;
        }
        cv_.notify_all();
    }
    
    auto get_scheduler(int priority = 0) {
        return std::execution::make_scheduler([this, priority](auto&& work) {
            std::lock_guard lock(mutex_);
            tasks_.push({priority, std::forward<decltype(work)>(work)});
            cv_.notify_one();
        });
    }
    
private:
    void worker_loop() {
        while (true) {
            Task task;
            {
                std::unique_lock lock(mutex_);
                cv_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
                
                if (stop_ && tasks_.empty()) return;
                
                task = std::move(tasks_.top());
                tasks_.pop();
            }
            task.work();
        }
    }
};

int main() {
    PriorityThreadPool pool(4);
    
    auto high_pri = pool.get_scheduler(10);
    auto low_pri = pool.get_scheduler(1);
    
    // 高优先级任务
    std::execution::schedule(high_pri)
        | std::execution::then([] { std::cout << "High priority task\n"; })
        | std::execution::submit();
    
    // 低优先级任务
    std::execution::schedule(low_pri)
        | std::execution::then([] { std::cout << "Low priority task\n"; })
        | std::execution::submit();
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

性能提示：在实际应用中，避免过度细分任务。任务调度本身有开销，通常每个任务至少应该有几千个时钟周期的计算量才能抵消调度开销。

4. 参数包索引与占位变量：模板编程的简化

C++26在模板元编程方面也带来了重大改进，特别是参数包索引和占位变量这两个特性，可以显著简化复杂的模板代码。

4.1 参数包索引的实际应用

参数包索引允许直接通过下标访问参数包中的元素，不再需要复杂的递归展开。让我们看几个实用场景：

场景1：获取参数包中的特定类型

cpp复制template <typename... Ts>
struct VariantHelper {
    // 获取第一个类型
    using First = Ts...[0];
    
    // 获取最后一个类型
    using Last = Ts...[sizeof...(Ts) - 1];
    
    // 获取中间类型
    using Middle = Ts...[sizeof...(Ts) / 2];
    
    // 检查是否包含特定类型
    template <typename T>
    static constexpr bool contains = (std::is_same_v<T, Ts> || ...);
};

static_assert(std::is_same_v<VariantHelper<int, double, std::string>::First, int>);
static_assert(std::is_same_v<VariantHelper<int, double, std::string>::Last, std::string>);
static_assert(VariantHelper<int, double, std::string>::contains<double>);

场景2：实现类型安全的printf

cpp复制#include <iostream>
#include <stdexcept>

void safe_printf(const char* format) {
    std::cout << format;
}

template <typename... Args>
void safe_printf(const char* format, Args... args) {
    for (; *format != '\0'; ++format) {
        if (*format == '%') {
            if (*(format + 1) == '\0') {
                throw std::invalid_argument("Invalid format string");
            }
            
            switch (*(++format)) {
                case 'd':
                    if constexpr (sizeof...(Args) > 0) {
                        if (!std::is_integral_v<Args...[0]>) {
                            throw std::invalid_argument("Expected integer argument");
                        }
                        std::cout << args...[0];
                        safe_printf(format + 1, args...[1:]...);
                        return;
                    }
                    break;
                case 'f':
                    if constexpr (sizeof...(Args) > 0) {
                        if (!std::is_floating_point_v<Args...[0]>) {
                            throw std::invalid_argument("Expected floating-point argument");
                        }
                        std::cout << args...[0];
                        safe_printf(format + 1, args...[1:]...);
                        return;
                    }
                    break;
                // 其他格式说明符...
                default:
                    throw std::invalid_argument("Unknown format specifier");
            }
        }
        std::cout << *format;
    }
}

int main() {
    safe_printf("Integer: %d, Float: %f\n", 42, 3.14);  // 正确
    // safe_printf("Integer: %d\n", "not a number");     // 编译时报错
}

4.2 占位变量的妙用

占位变量_是一个看似简单但极其实用的特性。它明确表示"我不关心这个值"，使代码意图更清晰。

用例1：结构化绑定中的忽略

cpp复制#include <tuple>
#include <map>

int main() {
    // 忽略map插入的iterator
    auto [success, _] = std::map<int, std::string>{}.insert({1, "one"});
    
    // 忽略tuple中的某些元素
    auto [x, _, y, _] = std::tuple{1, 2.0, 'a', "ignored"};
    
    // 在循环中忽略索引
    for (auto [_, value] : std::map<int, std::string>{{1, "a"}, {2, "b"}}) {
        std::cout << value << "\n";
    }
}

用例2：Lambda参数中的占位

cpp复制#include <algorithm>
#include <vector>

int main() {
    std::vector<std::tuple<int, std::string, double>> data = {
        {1, "Alice", 3.14},
        {2, "Bob", 2.71}
    };
    
    // 只关心第二个元素
    std::sort(data.begin(), data.end(), 
        [](const auto& a, const auto& b) {
            auto [_, name_a, __] = a;
            auto [__, name_b, ___] = b;
            return name_a < name_b;
        });
    
    // 更简洁的写法（C++26）
    std::sort(data.begin(), data.end(), 
        [](const auto& [_, a, __], const auto& [__, b, ___]) {
            return a < b;
        });
}

4.3 参数包切片的高级用法

虽然C++26标准中参数包切片语法尚未最终确定，但很可能会支持类似Args...[1:]的语法来获取子包。这在模板元编程中非常有用：

cpp复制template <typename... Args>
struct TupleTail {
    // 假设支持 Args...[1:] 语法
    using type = std::tuple<Args...[1:]...>;
};

static_assert(std::is_same_v<
    TupleTail<int, double, std::string>::type,
    std::tuple<double, std::string>>);

开发经验：当需要处理参数包时，先考虑是否能用参数包索引解决，这通常比递归模板更简单高效。只有在真正需要遍历所有元素时才使用折叠表达式或递归。

5. 其他重要特性详解

除了前面介绍的主要特性外，C++26还包含许多实用的改进，这些特性虽然看起来小，但在日常开发中能显著提高生产力和代码质量。

5.1 静态断言增强

static_assert现在支持动态生成的错误消息，这对于模板元编程特别有用：

cpp复制#include <format>
#include <type_traits>

template <typename T>
void check_type() {
    static_assert(
        std::is_integral_v<T> || std::is_floating_point_v<T>,
        std::format("Type {} must be arithmetic, but is {}",
            typeid(T).name(),
            std::is_class_v<T> ? "a class" : "unknown")
    );
}

int main() {
    check_type<int>();    // 通过
    // check_type<std::string>();  // 编译错误，显示详细消息
}

5.2 饱和算术

饱和算术对于图形处理、音频计算等领域非常重要，可以防止溢出导致的未定义行为：

cpp复制#include <numeric>
#include <cstdint>

int main() {
    uint8_t a = 200;
    uint8_t b = 100;
    
    // 普通加法会溢出
    auto normal = a + b;  // 44 (溢出)
    
    // 饱和加法限制在255
    auto saturated = std::add_sat(a, b);  // 255
    
    // 应用示例：颜色混合
    uint8_t red = 240;
    uint8_t green = 50;
    uint8_t blended = std::add_sat(red, green);  // 255，不会溢出变白
    
    // 有符号数饱和运算
    int16_t audio1 = 30000;
    int16_t audio2 = 10000;
    int16_t mixed = std::add_sat(audio1, audio2);  // 32767 (int16_t最大值)
}

5.3 #embed指令

#embed指令允许在编译时嵌入外部文件，这对于资源管理非常方便：

cpp复制#include <span>
#include <string_view>

// 嵌入GLSL着色器
constexpr std::string_view vertex_shader = 
    #embed "shaders/vertex.glsl"
    ;

// 嵌入二进制数据
constexpr std::span<const std::byte> icon_data = {
    #embed "assets/icon.png"
};

// 嵌入文本文件
constexpr std::string_view config_json = 
    #embed_string "config.json"
    ;

int main() {
    // 直接使用嵌入的数据
    glShaderSource(shader, 1, &vertex_shader.data(), nullptr);
}

5.4 调试支持

C++26新增的<debugging>头文件提供了标准化的调试接口：

cpp复制#include <debugging>

void critical_operation(int value) {
    if (value < 0) {
        // 仅在调试器中运行时中断
        if (std::is_debugger_present()) {
            std::breakpoint();
        } else {
            // 生产环境下的替代处理
            log_error("Invalid value: {}", value);
            throw std::invalid_argument("Value must be positive");
        }
    }
    
    // 条件断点
    std::breakpoint_if([value] { 
        return value > 1000;  // 只在值大于1000时中断
    });
    
    // 调试断言
    std::assert_in_debug(value != 0, "Value cannot be zero in debug mode");
}

5.5 线性代数库

C++26引入了标准线性代数库，基于std::mdspan：

cpp复制#include <linalg>
#include <mdspan>
#include <array>
#include <print>

int main() {
    // 3x3矩阵
    std::array<double, 9> a_data = {1,2,3, 4,5,6, 7,8,9};
    std::array<double, 9> b_data = {9,8,7, 6,5,4, 3,2,1};
    std::array<double, 9> c_data{};
    
    // 创建多维视图
    auto A = std::mdspan(a_data.data(), 3, 3);
    auto B = std::mdspan(b_data.data(), 3, 3);
    auto C = std::mdspan(c_data.data(), 3, 3);
    
    // 矩阵乘法
    std::linalg::matrix_product(A, B, C);
    
    // 矩阵向量乘法
    std::array<double, 3> x = {1, 0, 0};
    std::array<double, 3> y{};
    std::linalg::matrix_vector_product(A, std::mdspan(x.data(), 3), 
                                          std::mdspan(y.data(), 3));
    
    // 求解线性方程组
    std::linalg::triangular_matrix_vector_solve(A, std::linalg::upper_triangle,
                                                  std::mdspan(b_data.data(), 3),
                                                  std::mdspan(x.data(), 3));
    
    // 打印结果
    for (int i = 0; i < 3; ++i) {
        std::println("y[{}] = {}", i, y[i]);
    }
}

性能提示：线性代数操作会使用编译器优化的BLAS实现，对于性能关键的应用，确保启用适当的编译优化选项（如-Ofast -march=native）。

6. 内存安全改进

C++26在内存安全方面做出了重要改进，这对于构建可靠系统至关重要。

6.1 未初始化变量的确定性行为

在C++26中，读取未初始化的局部变量不再是未定义行为，而是产生一个不确定值：

cpp复制int main() {
    int x;  // 未初始化
    int y = x;  // C++26前：UB，可能崩溃
                // C++26：well-defined，x为不确定值
    
    // 不确定值可能是任何值，但不导致UB
    std::cout << "y = " << y << "\n";  // 可能输出任意值
}

虽然这看起来是个小变化，但它意味着：

1. 调试更容易：不会因为读取未初始化变量而出现随机崩溃
2. 安全分析更准确：静态分析工具可以更可靠地检测未初始化使用
3. 可移植性更好：不同编译器对这种情况的行为将一致

6.2 危险指针（Hazard Pointers）

危险指针是一种无锁编程技术，C++26将其标准化：

cpp复制#include <hazard_pointer>
#include <atomic>
#include <memory>

template <typename T>
class LockFreeStack {
    struct Node {
        std::shared_ptr<T> data;
        std::atomic<Node*> next;
        
        explicit Node(T&& val) 
            : data(std::make_shared<T>(std::move(val))), next(nullptr) {}
    };
    
    std::atomic<Node*> head_ = nullptr;
    
public:
    void push(T&& value) {
        Node* new_node = new Node(std::move(value));
        new_node->next = head_.load();
        while (!head_.compare_exchange_weak(new_node->next, new_node));
    }
    
    std::shared_ptr<T> pop() {
        std::hazard_pointer hp = std::make_hazard_pointer();
        Node* old_head = hp.protect(head_);
        
        while (old_head && 
               !head_.compare_exchange_strong(old_head, old_head->next)) {
            old_head = hp.protect(head_);
        }
        
        if (!old_head) return nullptr;
        
        auto res = old_head->data;
        hp.retire(old_head);  // 安全回收节点
        return res;
    }
};

6.3 RCU（Read-Copy-Update）

RCU是另一种无锁编程技术，特别适合读多写少的场景：

cpp复制#include <rcu>
#include <string>
#include <map>

class ConfigManager {
    std::map<std::string, std::string> config_;
    std::rcu_domain domain_;
    
public:
    std::string get(const std::string& key) {
        std::rcu_reader guard(domain_);  // 读锁
        auto it = config_.find(key);
        return it != config_.end() ? it->second : "";
    }
    
    void set(const std::string& key, std::string value) {
        // 创建新配置的副本
        auto new_config = std::make_shared<std::map<std::string, std::string>>(config_);
        (*new_config)[key] = std::move(value);
        
        // 原子替换
        std::rcu_assign_pointer(config_, new_config);
        
        // 延迟回收旧数据
        std::rcu_retire(config_, [](auto ptr) {
            delete ptr;
        });
    }
};

并发编程经验：危险指针适合写操作频繁的场景，而RCU适合读操作远多于写操作的场景。选择哪种技术取决于具体的访问模式。

7. 迁移策略与最佳实践

将现有代码迁移到C++26需要谨慎规划。根据我的经验，以下策略最为有效：

7.1 渐进式采用路线图

7.2 静态反射的迁移策略

1. 从枚举处理开始：替换现有的enum-to-string工具
2. 逐步替换代码生成器：如序列化、RPC框架等
3. 最后处理复杂元编程：如表达式模板、DSL等

cpp复制// 迁移示例：替换旧的枚举字符串化
enum class OldColor { Red, Green, Blue };

// 旧方法：宏生成
const char* to_string(OldColor c) {
    switch (c) {
        case OldColor::Red: return "Red";
        case OldColor::Green: return "Green";
        case OldColor::Blue: return "Blue";
    }
}

// 新方法：静态反射
enum class NewColor { red, green, blue };

template <typename E>
    requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
    template for (constexpr auto e : std::meta::members_of(^E)) {
        if (value == [:e:]) {
            return std::string(std::meta::name_of(e));
        }
    }
    return "<unknown>";
}

7.3 契约编程的引入建议

1. 从新代码开始：在新编写的类和方法中添加契约
2. 关键模块优先：如安全关键组件、核心算法
3. 逐步改造旧代码：每次修改时添加相关契约

cpp复制// 改造前
double calculate(double x, double y) {
    if (y == 0) throw std::invalid_argument("y cannot be zero");
    return x / y;
}

// 改造后
double calculate(double x, double y)
    [[pre: y != 0]]
    [[post r: std::abs(r * y - x) < 1e-9]]
{
    return x / y;
}

7.4 std::execution的整合方法

1. 替代简单并行算法：如std::for_each的并行版本
2. 改造回调地狱：将嵌套回调改为链式调用
3. 构建新异步框架：基于Sender/Receiver设计异步系统

cpp复制// 改造前：回调地狱
void fetch_data(std::function<void(Data)> callback) {
    async_op1([callback](auto r1) {
        async_op2(r1, [callback](auto r2) {
            async_op3(r2, [callback](auto r3) {
                callback(process(r3));
            });
        });
    });
}

// 改造后：链式调用
auto fetch_data() {
    return std::execution::schedule(pool)
         | std::execution::then([] { return async_op1(); })
         | std::execution::then([](auto r1) { return async_op2(r1); })
         | std::execution::then([](auto r2) { return async_op3(r2); })
         | std::execution::then([](auto r3) { return process(r3); });
}

7.5 构建系统调整

C++26特性需要编译器支持，CMake配置示例：

cmake复制# 检查编译器支持
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0)
        message(FATAL_ERROR "GCC 15.0+ required for C++26 support")
    endif()
    set(CXX26_FLAGS "-std=c++26")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 17.0)
        message(FATAL_ERROR "Clang 17.0+ required for C++26 support")
    endif()
    set(CXX26_FLAGS "-std=c++26 -Xclang -enable-cxx26-experimental")
endif()

# 为目标设置编译选项
target_compile_options(my_target PRIVATE ${CXX