详解C++26 新特性

#include <meta>  // 新的反射头文件
#include <string>

enum class Color { 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 "<unnamed>";
}

int main() {
    static_assert(enum_to_string(Color::red) == "red");
    static_assert(enum_to_string(Color::blue) == "blue");

int divide(int a, int b)
    [[pre: b != 0]]                    // 前置条件：除数不能为0
    [[post r: r * b == a]]             // 后置条件：结果验证 （返回值用r标记）
{
    return a / b;
}

// 类不变式
class Stack {
    int size_ = 0;
    int* data_ = nullptr;
    
public:
    void push(int val)
        [[pre: size_ < capacity()]]     // 栈未满
        [[post: size() == old size() + 1]]  // 大小增加1
    {
        data_[size_++] = val;
    }
    
    int pop()
        [[pre: size_ > 0]]              // 栈非空
        [[post: size() == old size() - 1]]
    {
        return data_[--size_];
    }
};

#include <execution>
#include <iostream>

int main() {
    auto sch = std::execution::get_scheduler();  // 获取默认调度器

    // 1) 从调度器得到一个 sender
    auto snd = std::execution::schedule(sch);

    // 2) then 在其上接一个同步任务，返回 int
    auto snd2 = std::execution::then(snd, [] {
        std::cout << "Hello from std::execution\n";
        return 42;
    });

    // 3) 再接一个任务消费 int
    auto snd3 = std::execution::then(snd2, [](int x) {
        std::cout << "Got " << x << "\n";
    });

    // 4) 提交并等待完成（具体细节略有出入，此处为示意）
    std::execution::sync_wait(snd3);
}

auto [a, _, _] = std::tuple{1, 2.0, 'x'};
// _ 没有名字，不能用 _ 去读；只表示“占位”

template<typename... Ts>
constexpr auto first_plus_last(Ts... values)
    -> Ts...[0]               // 包的第 0 号类型作为返回类型
{
    return Ts...[0](values...[0] + values...[sizeof...(values) - 1]);
}

static_assert(first_plus_last(1, 2, 11) == 12);

struct A { char c; };

static_assert(
    sizeof(A) == 1,
    std::format("Unexpected sizeof: expected 1, got {}", sizeof(A))
);

#include <linalg> //新增头文件
#include <mdspan>
#include <array>

int main() {
    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);  // C = A * B
}