1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <iostream>
#include <expected>
#include <string>

// 定义一个可能失败的解析函数
// 返回 std::expected<int, std::string>
// - 成功时返回 int 类型值
// - 失败时返回 std::string 类型的错误信息
std::expected<int, std::string> parseInt(const std::string& s) {
    try {
        // std::stoi 是标准库函数，将字符串转换为整数
        // 如果转换失败，会抛出 std::invalid_argument 或 std::out_of_range 异常
        return std::stoi(s);
    } catch (...) {
        // 捕获所有异常，并返回一个"意外"结果
        // std::unexpected() 是 C++23 新增的辅助函数
        return std::unexpected("Failed to parse: " + s);
    }
}

int main() {
    // 测试一个合法的数字字符串
    auto r1 = parseInt("42");
    
    // 检查是否成功——std::expected 支持布尔转换
    if (r1) {
        // 解引用获取值
        std::cout << "Parsed: " << *r1 << std::endl;  // 输出: Parsed: 42
    }
    
    // 测试一个非数字字符串
    auto r2 = parseInt("not a number");
    
    // 失败时，!r2 为 true
    if (!r2) {
        // 获取错误信息
        std::cout << "Error: " << r2.error() << std::endl;  // 输出: Error: Failed to parse: not a number
    }
    
    // 还有更多骚操作！
    // r1.value() - 类似解引用，但会在失败时抛出异常
    // r1.value_or(0) - 获取值，失败时返回默认值
    // r1.has_value() - 检查是否有值
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 方式一：异常（性能开销大，不适合性能敏感场景）
int parseInt_Exception(const std::string& s) {
    return std::stoi(s);  // 失败就抛异常，catch不到就程序崩溃
}

// 方式二：返回错误码（繁琐）
std::pair<bool, int> parseInt_ErrCode(const std::string& s) {
    try {
        return {true, std::stoi(s)};
    } catch (...) {
        return {false, 0};
    }
}

// 方式三：std::expected（优雅！）
auto parseInt_Expected(const std::string& s) -> std::expected<int, std::string> {
    try {
        return std::stoi(s);
    } catch (...) {
        return std::unexpected("解析失败：" + s);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
#include <functional>
#include <memory>

int main() {
    // 创建一个只移动的函数包装器
    // 返回类型是 int，参数是 void
    std::move_only_function<int()> func1 = []{ return 42; };
    
    // 调用它
    int result = func1();  // 调用 operator()
    std::cout << "func1() = " << result << std::endl;  // 输出: func1() = 42
    
    // 移动语义演示
    // func1 被"转移"给 func2，之后 func1 变为空壳
    std::move_only_function<int()> func2 = std::move(func1);
    
    // func1 现在是空的！调用它会抛出 std::bad_function_call 异常
    // int r1 = func1();  // 请不要取消注释！会爆炸！
    
    // func2 仍然有效
    std::cout << "func2() = " << func2() << std::endl;  // 输出: func2() = 42
    
    // 存储不可复制的可调用对象
    auto uptr = std::make_unique<int>(100);
    std::move_only_function<int()> funcWithUnique = [ptr = std::move(uptr)]() mutable {
        return *ptr;  // 独占所有权的智能指针
    };
    
    std::cout << "funcWithUnique() = " << funcWithUnique() << std::endl;  // 输出: funcWithUnique() = 100
    
    return 0;
}

1

auto g = std::bind(f, std::placeholders::_1, std::placeholders::_2, 10);  // 辣眼睛！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <iostream>
#include <functional>

int main() {
    // 定义一个三元函数
    auto f = [](int a, int b, int c) { 
        return a + b + c; 
    };
    
    // std::bind_back: 绑定尾部的参数！
    // 绑定 b=10, c=20，那么调用 g(a) 就等于 f(a, 10, 20)
    auto g = std::bind_back(f, 10, 20);
    
    // 调用 g(5) => f(5, 10, 20) => 35
    std::cout << "g(5) = " << g(5) << std::endl;  // 输出: g(5) = 35
    
    // 绑定更多参数
    auto h = std::bind_back(f, 100);  // 只绑定 c=100
    // 调用 h(1, 2) => f(1, 2, 100) => 103
    std::cout << "h(1, 2) = " << h(1, 2) << std::endl;  // 输出: h(1, 2) = 103
    
    // 完美适配成员函数！
    struct Calculator {
        int add(int x, int y) const { return x + y; }
    };
    
    Calculator calc;
    
    // 绑定成员函数的尾部参数
    // std::bind_back 也适用于成员函数！
    auto boundAdd = std::bind_back(&Calculator::add, &calc, 100);
    // 调用 boundAdd(5) => calc.add(5, 100) => 105
    std::cout << "boundAdd(5) = " << boundAdd(5) << std::endl;  // 输出: boundAdd(5) = 105
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <bit>
#include <cstdint>

int main() {
    // 一个32位整数
    unsigned int val = 0x12345678;  // 十六进制表示
    
    // std::byteswap: 反转字节顺序！
    // 0x12345678 -> 0x78563412
    auto swapped = std::byteswap(val);
    
    std::cout << "Original: 0x" << std::hex << val << std::endl;      // 输出: Original: 0x12345678
    std::cout << "Swapped:  0x" << swapped << std::endl;               // 输出: Swapped:  0x78563412
    
    // 16位短整数演示
    std::uint16_t short_val = 0x1234;
    auto short_swapped = std::byteswap(short_val);
    std::cout << "Short Original: 0x" << short_val << std::endl;      // 输出: Short Original: 0x1234
    std::cout << "Short Swapped:  0x" << short_swapped << std::endl;  // 输出: Short Swapped:  0x3412
    
    // 64位长整数演示
    std::uint64_t long_val = 0x0123456789ABCDEF;
    auto long_swapped = std::byteswap(long_val);
    std::cout << "Long Original: 0x" << long_val << std::endl;         // 输出: Long Original: 0x123456789abcdef
    std::cout << "Long Swapped:  0x" << long_swapped << std::endl;     // 输出: Long Swapped:  0xefcdab8967452301
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
#include <utility>

struct MyStruct {
    int value = 42;
};

void process(int& x) { std::cout << "Lvalue overload" << std::endl; }
void process(int&& x) { std::cout << "Rvalue overload" << std::endl; }

template<typename T>
void wrapper(T&& arg) {
    // std::forward_like<T> 会根据 T 的值类别
    // 决定返回左值引用还是右值引用
    auto forwarded = std::forward_like<T>(arg);
    
    // 打印 forwarded 的类型信息
    // 如果 T 是 MyStruct&，forwarded 就是 MyStruct&
    // 如果 T 是 MyStruct，forwarded 就是 MyStruct&&
    std::cout << "Type info: ";
    process(std::forward_like<T>(arg));
}

int main() {
    MyStruct obj;
    
    std::cout << "Calling with lvalue: ";
    wrapper(obj);  // T = MyStruct&, 转发为 lvalue
    
    std::cout << "Calling with rvalue: ";
    wrapper(std::move(obj));  // T = MyStruct, 转发为 rvalue
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
#include <functional>
#include <string>

int main() {
    // 普通Lambda
    auto f = []() { return 42; };
    int result = std::invoke_r<int>(f);  // 指定返回 int
    std::cout << "result = " << result << std::endl;  // 输出: result = 42
    
    // 返回类型不匹配时，可以进行转换！
    auto g = []() -> double { return 3.14; };
    int truncated = std::invoke_r<int>(g);  // double -> int，丢失小数部分
    std::cout << "truncated = " << truncated << std::endl;  // 输出: truncated = 3
    
    // void 返回类型
    auto h = []() { std::cout << "Hello from void lambda!" << std::endl; };
    std::invoke_r<void>(h);  // 输出: Hello from void lambda!
    
    // 成员函数调用
    struct S {
        int method() { return 100; }
    };
    S s;
    int method_result = std::invoke_r<int>(&S::method, s);
    std::cout << "method_result = " << method_result << std::endl;  // 输出: method_result = 100
    
    // std::invoke_r vs std::invoke
    // std::invoke 会自动推导返回类型
    // std::invoke_r 强制转换为你指定的类型
    
    return 0;
}

1
2

Color c = Color::Green;
int underlying = static_cast<int>(c);  // 辣眼睛！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
#include <utility>

// 定义一个强类型枚举，默认底层类型是 int
enum class Color : int { Red = 1, Green = 2, Blue = 3 };

// 也可以显式指定其他底层类型
enum class Status : unsigned char { OK = 0, Error = 1, Pending = 2 };

int main() {
    Color c = Color::Green;
    
    // 使用 std::to_underlying 获取底层值！
    int underlying = std::to_underlying(c);
    std::cout << "underlying = " << underlying << std::endl;  // 输出: underlying = 2
    
    // 处理其他底层类型的枚举
    Status s = Status::Error;
    auto status_val = std::to_underlying(s);
    std::cout << "status_val = " << static_cast<int>(status_val) << std::endl;  // 输出: status_val = 1
    
    // 在switch中使用
    switch (std::to_underlying(c)) {
        case 1: std::cout << "Red" << std::endl; break;
        case 2: std::cout << "Green" << std::endl; break;
        case 3: std::cout << "Blue" << std::endl; break;
    }
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <utility>

// 定义一个状态枚举
enum class State { Start, Middle, End };

// 定义一个操作函数
void process(State s) {
    switch (s) {
        case State::Start: 
            std::cout << "Starting..." << std::endl; 
            break;
        case State::Middle: 
            std::cout << "Middle of work" << std::endl; 
            break;
        case State::End: 
            std::cout << "Finished!" << std::endl; 
            break;
        default:
            // 默认分支，告诉编译器这是不可能到达的
            // 如果真的到达了，程序会 std::terminate()（而非 abort！）
            std::unreachable();  // C++23
    }
}

int main() {
    process(State::Start);    // 输出: Starting...
    process(State::Middle);   // 输出: Middle of work
    process(State::End);      // 输出: Finished!
    
    // 如果你尝试 process(static_cast<State>(999));
    // 程序会 std::terminate()
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 没有 std::unreachable
void process_slow(State s) {
    switch (s) {
        case State::A: return f();
        case State::B: return g();
        case State::C: return h();
        default: return;  // 编译器必须生成处理"未知值"的代码
    }
}

// 有 std::unreachable
void process_fast(State s) {
    switch (s) {
        case State::A: return f();
        case State::B: return g();
        case State::C: return h();
        default: std::unreachable();  // 编译器可以大胆假设永远不会到这里
    }
}

1
2
3
4
5
6

// C++17 时代的痛苦
std::optional<int> opt = getOptional();
if (opt.has_value()) {
    int val = *opt;
    // 对 val 做点什么...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>
#include <optional>

int main() {
    std::optional<int> opt = 42;
    
    // 1. and_then: 如果有值，执行函数返回新的 optional
    // 如果是空，直接返回空 optional
    auto result1 = opt.and_then([](int x) {
        return std::optional<int>(x * 2);
    });
    std::cout << "and_then result: " << (result1 ? std::to_string(*result1) : "nullopt") << std::endl;
    // 输出: and_then result: 84
    
    // 2. map: 如果有值，对值做变换，返回新的 optional
    auto result2 = opt.map([](int x) {
        return x * 3;  // 返回非 optional，但会被自动包装
    });
    std::cout << "map result: " << (result2 ? std::to_string(*result2) : "nullopt") << std::endl;
    // 输出: map result: 126
    
    // 3. transform: 和 map 类似，但是用于 void 的情况
    opt.transform([](int x) {
        std::cout << "transforming " << x << std::endl;
    });
    
    // 4. or_else: 如果是空，执行函数返回默认值
    std::optional<int> empty_opt;
    auto result3 = empty_opt.or_else([] {
        return std::optional<int>(-1);
    });
    std::cout << "or_else result: " << *result3 << std::endl;  // 输出: -1
    
    // 链式调用！
    auto final_result = opt
        .and_then([](int x) { return std::optional<int>(x + 1); })
        .map([](int x) { return x * 2; })
        .or_else([] { return std::optional<int>(0); });
    
    std::cout << "Chained result: " << *final_result << std::endl;  // 输出: 86
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <iostream>
// #include <generator>  // 实验性支持

// 定义一个生成器：生成斐波那契数列
// std::generator<yield_type, argument_type>
std::generator<int, int> fibonacci(int n) {
    // co_yield 类似于 return，但下次调用时会从这里继续
    co_yield 0;   // 第一个数字
    co_yield 1;   // 第二个数字
    
    int a = 0, b = 1;
    for (int i = 2; i < n; ++i) {
        int next = a + b;
        co_yield next;  // 产出当前值
        a = b;
        b = next;
    }
}

// 生成偶数的生成器
std::generator<int> generateEvens(int start) {
    for (int i = start; ; i += 2) {
        co_yield i;  // 无限序列！
    }
}

int main() {
    std::cout << "std::generator in C++23 (conceptual example)" << std::endl;
    
    // 注意：由于编译器支持有限，这里展示概念而非可编译代码
    /*
    // 使用斐波那契生成器
    for (int fib : fibonacci(10)) {
        std::cout << fib << " ";  // 输出: 0 1 1 2 3 5 8 13 21 34
    }
    std::cout << std::endl;
    
    // 只取前5个
    int count = 0;
    for (int fib : fibonacci(1000)) {
        std::cout << fib << " ";
        if (++count >= 5) break;  // 惰性！只计算了5个
    }
    */
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <iostream>
#include <stacktrace>
#include <string>

// 辅助函数：打印堆栈跟踪
void printStackTrace(const std::stacktrace& trace = std::stacktrace::current()) {
    std::cout << "=== Stack Trace (" << trace.size() << " frames) ===" << std::endl;
    
    // 遍历每一个栈帧
    for (size_t i = 0; i < trace.size(); ++i) {
        const std::stacktrace_entry& frame = trace[i];
        
        // 获取帧的信息
        std::cout << "Frame " << i << ": " << frame.description() << std::endl;
        // frameNativeHandle() 可以获取原生句柄
        // to_string() 可以获取完整描述
    }
}

// 层级3：最深层的函数
void level3() {
    std::cout << "In level3()" << std::endl;
    auto trace = std::stacktrace::current();
    std::cout << "level3 stacktrace has " << trace.size() << " frames" << std::endl;
}

// 层级2：调用level3
void level2() {
    std::cout << "In level2()" << std::endl;
    level3();
}

// 层级1：调用level2
void level1() {
    std::cout << "In level1()" << std::endl;
    level2();
}

int main() {
    std::cout << "=== Stacktrace Demo ===" << std::endl;
    
    // 获取当前调用栈
    auto trace = std::stacktrace::current();
    std::cout << "Stack trace has " << trace.size() << " frames" << std::endl;
    
    for (const auto& frame : trace) {
        std::cout << frame << std::endl;
    }
    
    std::cout << "\n=== Nested Call Demo ===" << std::endl;
    level1();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>
#include <print>

int main() {
    // 基本打印（类似 cout，但更好用）
    std::print("Hello, World!\n");  // 不自动换行
    std::println("Hello, World!");  // 自动换行
    
    // 格式化字符串！
    std::print("Name: {}, Age: {}\n", "Alice", 30);
    // 输出: Name: Alice, Age: 30
    
    // 位置参数
    std::print("{1} {0} {2}\n", "brown", "fox", "jumps");
    // 输出: fox brown jumps
    
    // 数字格式化
    std::print("Pi: {:.4f}\n", 3.14159265);
    // 输出: Pi: 3.1416
    
    std::print("Hex: {:#x}\n", 255);
    // 输出: Hex: 0xff
    
    std::print("Binary: {:b}\n", 42);
    // 输出: Binary: 101010
    
    // 对齐和填充
    std::print("|{:>10}|\n", "right");    // 右对齐
    std::print("|{:<10}|\n", "left");     // 左对齐
    std::print("|{:^10}|\n", "center");  // 居中
    
    // 输出到文件
    // std::ofstream file("output.txt");
    // std::print(file, "Writing to file: {}\n", 123);
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
// #include <mdspan>  // 实验性支持

int main() {
    std::cout << "std::mdspan in C++23 (conceptual example)" << std::endl;
    
    /*
    // 原始数据：一维数组
    int data[] = {1, 2, 3, 4, 5, 6};
    
    // 将 data 视图化为 2x3 的二维数组
    // std::extents<size_t, 2, 3> 指定维度为 2 行 3 列
    std::mdspan<int, std::extents<size_t, 2, 3>> matrix(data);
    
    // 按行列访问
    std::cout << matrix[0, 0] << std::endl;  // 输出: 1 (第0行第0列)
    std::cout << matrix[0, 1] << std::endl;  // 输出: 2 (第0行第1列)
    std::cout << matrix[1, 2] << std::endl;  // 输出: 6 (第1行第2列)
    
    // 获取维度信息
    std::cout << "Rows: " << matrix.extent(0) << std::endl;  // 输出: 2
    std::cout << "Cols: " << matrix.extent(1) << std::endl;  // 输出: 3
    
    // 同一个数据，不同视角！
    // 3x2 的视图
    std::mdspan<int, std::extents<size_t, 3, 2>> transposed(data);
    std::cout << transposed[0, 0] << std::endl;  // 输出: 1
    std::cout << transposed[2, 1] << std::endl;  // 输出: 6
    
    // 动态维度
    std::mdspan<int, std::dextents<size_t, 2>> dynamic_matrix(
        data, 
        std::dextents<size_t, 2>{2, 3}  // 运行时指定维度
    );
    */
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
// #include <flat_map>
// #include <flat_set>

int main() {
    std::cout << "Flat containers in C++23 (conceptual example)" << std::endl;
    
    /*
    // flat_set 示例
    std::flat_set<int> fs = {5, 2, 8, 1, 9};
    // 内部存储：[1, 2, 5, 8, 9]（有序、连续）
    
    // 查找
    auto it = fs.find(5);
    if (it != fs.end()) {
        std::cout << "Found: " << *it << std::endl;
    }
    
    // flat_map 示例
    std::flat_map<std::string, int> fm = {
        {"apple", 1},
        {"banana", 2},
        {"cherry", 3}
    };
    
    // 插入（可能需要移动元素）
    fm.insert({"date", 4});
    
    // 访问
    std::cout << fm["apple"] << std::endl;  // 输出: 1
    
    // 迭代器是随机访问的！（普通map是双向迭代器）
    // 可以用 fs.begin() + 3 这种骚操作
    
    // 优点：更好的缓存局部性
    // 缺点：插入/删除是 O(n)，而普通 map 是 O(log n)
    */
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::cout << "New range adaptors in C++23" << std::endl;
    
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
    
    // views::adjacent - 生成滑动窗口（窗口大小默认2）
    // auto pairs = nums | std::views::adjacent;  // 生成 [(1,2), (2,3), ...]
    
    // views::chunk_by - 按条件分组
    // auto groups = nums | std::views::chunk_by([](int a, int b) { return a + 1 == b; });
    // [1,2,3] 是一组（连续），[4,5,6] 是另一组
    
    // views::cartesian_product - 笛卡尔积
    // std::vector<int> a = {1, 2}, b = {10, 20};
    // auto product = std::views::cartesian_product(a, b);
    // 结果：[(1,10), (1,20), (2,10), (2,20)]
    
    // views::as_const - 防止修改
    // auto const_view = nums | std::views::as_const;
    
    std::cout << "Range adaptors provide lazy, composable transformations!" << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 传统方式：循环嵌套循环
for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
        process(i, j);
    }
}

// 范围方式：优雅的管道链
nums 
    | std::views::filter([](int x) { return x % 2 == 0; })  // 过滤偶数
    | std::views::transform([](int x) { return x * x; })     // 平方
    | std::views::take(5)                                     // 取前5个
    | std::views::reverse;                                    // 反转

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>

int main() {
    // std::basic_common_reference 是模板元编程的工具
    // 它用于定义"common reference"——两个类型可以互相转换的引用类型
    
    // 简单示例：
    // 对于 T& 和 T&&，common reference 是 T&
    // 对于 T& 和 const T&，common reference 是 const T&
    
    // C++23 对 basic_common_reference 进行了改进
    // 使其更好地支持自定义类型之间的转换
    
    std::cout << "Improvements to basic_common_reference in C++23" << std::endl;
    std::cout << "This is a metaprogramming facility for library authors." << std::endl;
    
    return 0;
}

1
2

std::pair<int, int> p = {1, 2};
auto [x, y] = p;  // x=1, y=2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <iostream>
#include <tuple>

// 定义一个简单的点结构
struct Point {
    int x;
    int y;
    
    // 1. 提供 get<I>() 方法
    // 模板参数 I 是元组索引（0, 1, 2, ...）
    template<size_t I>
    auto get() const {
        if constexpr (I == 0) return x;
        else if constexpr (I == 1) return y;
        else static_assert(I < 2, "Point only has 2 elements!");
    }
};

// 2. 在 std 命名空间中特化 tuple_size 和 tuple_element
namespace std {
    // 告诉 std::tuple_size：Point 有 2 个元素
    template<>
    struct tuple_size<Point> : integral_constant<size_t, 2> {};
    
    // 告诉 std::tuple_element：Point 的第 I 个元素类型是什么
    template<size_t I>
    struct tuple_element<I, Point> {
        using type = int;  // Point 的两个元素都是 int
    };
}

// 现在 Point 可以使用结构化绑定了！
int main() {
    Point p{1, 2};
    
    // 结构化绑定！
    auto [px, py] = p;
    std::cout << "x=" << px << ", y=" << py << std::endl;  // 输出: x=1, y=2
    
    // 还能用于 std::tuple 算法
    std::tuple<Point> tp = std::make_tuple(p);
    
    // 交换两个 Point 的值
    Point p1{10, 20};
    Point p2{30, 40};
    std::swap(p1, p2);  // 现在 swap 也支持了！
    
    std::cout << "After swap: p1=(" << p1.x << "," << p1.y << ")" << std::endl;
    // 输出: After swap: p1=(30,40)
    
    return 0;
}

1
2

std::pair<int, std::string> p1(1, "default");  // 传统方式
std::pair p2(1);  // C++23之前：编译错误！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <utility>
#include <string>
#include <vector>

int main() {
    // C++23: pair支持不完整的构造
    // 注意：std::string 无法从 int 构造，所以下面的写法是错的！
    // std::pair<int, std::string> p(1);  // ❌ 编译错误！std::string 没有接受 int 的构造函数
    // std::tuple<int, double, std::string> t(10);  // ❌ 同样的问题
    
    // 正确用法：第二个元素的类型必须能从 int 构造，或者有默认构造函数
    std::pair<int, std::vector<int>> p(42);  // int(42) + vector<int>() 默认构造
    std::cout << "p.first = " << p.first << std::endl;       // 输出: 42
    std::cout << "p.second.empty() = " << p.second.empty() << std::endl;  // 输出: 1 (true)
    
    // tuple 也支持类似用法
    std::tuple<int, double, std::vector<int>> t(10, 3.14);  // 前两个用提供的值，vector默认构造
    std::cout << "get<0>(t) = " << std::get<0>(t) << std::endl;  // 输出: 10
    std::cout << "get<1>(t) = " << std::get<1>(t) << std::endl;  // 输出: 3.14
    std::cout << "get<2>(t).empty() = " << std::get<2>(t).empty() << std::endl;  // 输出: 1 (true)
    
    // 甚至可以只提供一个元素，其余默认构造
    std::pair<double, std::string> partial(2.718);
    std::cout << "partial.first = " << partial.first << std::endl;  // 输出: 2.718
    std::cout << "partial.second.empty() = " << partial.second.empty() << std::endl;  // 输出: 1 (true)
    
    return 0;
}

1
2
3
4

// 传统方式：尴尬的写法
for (size_t i = 0; i < vec.size(); ++i) {  // i 是无符号的
    // 如果你想 i-- 减到负数... 灾难！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
#include <vector>
#include <list>
#include <array>

int main() {
    std::vector<int> v{1, 2, 3, 4, 5};
    
    // std::size: 返回 size_t（无符号）
    std::size_t unsigned_size = std::size(v);
    std::cout << "std::size = " << unsigned_size << std::endl;  // 输出: 5
    
    // std::ssize: 返回 ptrdiff_t（带符号！）
    std::ptrdiff_t signed_size = std::ssize(v);
    std::cout << "std::ssize = " << signed_size << std::endl;  // 输出: 5
    
    // 优势1：可以安全地做减法
    std::ptrdiff_t half = std::ssize(v) / 2;
    std::cout << "Half size = " << half << std::endl;  // 输出: 2
    
    // 优势2：可以表示"负数"表示法
    // 比如，从末尾往前遍历
    for (std::ptrdiff_t i = std::ssize(v) - 1; i >= 0; --i) {
        std::cout << v[i] << " ";  // 输出: 5 4 3 2 1
    }
    std::cout << std::endl;
    
    // 支持所有容器
    std::list<double> lst = {1.1, 2.2, 3.3};
    std::cout << "list ssize = " << std::ssize(lst) << std::endl;  // 输出: 3
    
    std::array<char, 4> arr = {'a', 'b', 'c', 'd'};
    std::cout << "array ssize = " << std::ssize(arr) << std::endl;  // 输出: 4
    
    // C风格数组也支持！
    int raw[] = {10, 20, 30};
    std::cout << "raw array ssize = " << std::ssize(raw) << std::endl;  // 输出: 3
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <iostream>
#include <array>
#include <string>
#include <vector>

int main() {
    // 从初始化列表创建 array
    auto arr1 = std::to_array({1, 2, 3, 4, 5});
    std::cout << "arr1.size() = " << arr1.size() << std::endl;  // 输出: 5
    std::cout << "arr1[2] = " << arr1[2] << std::endl;           // 输出: 3
    
    // 从字符串数组创建
    auto arr2 = std::to_array({"apple", "banana", "cherry"});
    std::cout << "arr2.size() = " << arr2.size() << std::endl;  // 输出: 3
    std::cout << "arr2[1] = " << arr2[1] << std::endl;           // 输出: banana
    
    // 自动推断元素类型
    auto arr3 = std::to_array({1.1, 2.2, 3.3});
    std::cout << "arr3 element type is double: " 
              << std::is_same_v<decltype(arr3)::value_type, double> << std::endl;
    // 输出: 1 (true)
    
    // 拷贝构造（注意：不是引用！）
    int raw[] = {10, 20, 30};
    auto arr4 = std::to_array(raw);  // 拷贝！
    arr4[0] = 999;  // raw[0] 还是 10
    std::cout << "raw[0] = " << raw[0] << std::endl;  // 输出: 10
    
    // 从 vector 创建（注意：需要显式指定类型）
    std::vector<int> vec = {100, 200, 300};
    // auto arr5 = std::to_array(vec);  // 错误！不能从 vector 直接创建
    // 正确做法：
    std::array<int, 3> arr5 = {vec[0], vec[1], vec[2]};
    
    return 0;
}

1
2
3

std::unordered_map<std::string, int> m;
// m.find("hello");  // OK，const char* 可以转换为 std::string
// m.find(42);  // 编译错误！int 不能转 std::string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <iostream>
#include <unordered_map>
#include <string_view>

int main() {
    // C++23: 使用 std::unordered_map::find 的异构版本
    std::unordered_map<std::string, int> m = {
        {"apple", 1},
        {"banana", 2},
        {"cherry", 3}
    };
    
    // C++23之前：必须构造完整的 std::string
    auto it1 = m.find(std::string("apple"));  // 需要分配内存
    
    // C++23：直接使用 string_view（不需要分配内存！）
    auto it2 = m.find(std::string_view("banana"));
    
    // 查找成功
    if (it1 != m.end()) {
        std::cout << "Found: " << it1->second << std::endl;  // 输出: Found: 1
    }
    if (it2 != m.end()) {
        std::cout << "Found: " << it2->second << std::endl;  // 输出: Found: 2
    }
    
    // operator[] 也支持异构（只在 C++23 unordered_map！）
    // m[std::string_view("date")] = 4;  // 如果不存在，会插入
    
    // 注意：这是通过自定义 allocator 和 key_eq 实现的
    // 需要使用 std::unordered_map 的新构造函数或 empty() + insert()
    
    std::cout << "Heterogeneous lookup in unordered containers (C++23)" << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
#include <memory_resource>
#include <vector>
#include <string>

int main() {
    // 使用默认的内存资源
    std::pmr::polymorphic_allocator<> alloc;
    
    // 创建一个使用 polymorphic_allocator 的 vector
    std::pmr::vector<int> vec(alloc);
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    
    std::cout << "vector size: " << vec.size() << std::endl;
    
    // 使用内存池资源
    // std::pmr::synchronized_pool_resource pool;
    // std::pmr::polymorphic_allocator<> pool_alloc(&pool);
    
    // C++23 增强：
    // - 新增 std::pmr::memory_resource* std::get_default_resource() 
    // - 新增 std::pmr::set_default_resource()
    // - 新增 pool_resource 的更多选项
    
    std::cout << "Enhancements to polymorphic_allocator in C++23" << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <algorithm>

int main() {
    // 删除所有值为3的元素
    std::vector<int> v{1, 2, 3, 4, 3, 5, 3};
    std::erase(v, 3);  // C++20
    std::cout << "After erase(3): ";
    for (int x : v) std::cout << x << " ";  // 输出: 1 2 4 5
    std::cout << std::endl;
    
    // 删除所有满足条件的元素
    std::vector<int> v2{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::erase_if(v2, [](int x) { return x % 2 == 0; });  // 删除偶数
    std::cout << "After erase_if(even): ";
    for (int x : v2) std::cout << x << " ";  // 输出: 1 3 5 7 9
    std::cout << std::endl;
    
    // std::erase 也适用于 std::list, std::string 等
    std::string s = "Hello World";
    std::erase(s, 'l');  // 删除所有 'l'
    std::cout << "After erase('l'): " << s << std::endl;  // 输出: Heo Word
    
    // list 也支持 erase
    std::list<int> lst{1, 2, 3, 4, 5};
    std::erase(lst, 3);
    std::cout << "list after erase: ";
    for (int x : lst) std::cout << x << " ";  // 输出: 1 2 4 5
    std::cout << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <iostream>
#include <numeric>
#include <cmath>

int main() {
    // std::midpoint: 计算中点
    std::cout << "std::midpoint(1, 9) = " << std::midpoint(1, 9) << std::endl;  // 输出: 5
    std::cout << "std::midpoint(0.0, 1.0) = " << std::midpoint(0.0, 1.0) << std::endl;  // 输出: 0.5
    
    // 处理整数溢出
    int a = INT_MAX - 1;
    int b = INT_MAX;
    std::cout << "Safe midpoint of INT_MAX-1 and INT_MAX: " << std::midpoint(a, b) << std::endl;
    // 不会溢出！
    
    // std::lerp: 线性插值
    // lerp(a, b, t) = a + t * (b - a)
    std::cout << "std::lerp(0.0, 100.0, 0.0) = " << std::lerp(0.0, 100.0, 0.0) << std::endl;  // 输出: 0
    std::cout << "std::lerp(0.0, 100.0, 0.5) = " << std::lerp(0.0, 100.0, 0.5) << std::endl;  // 输出: 50
    std::cout << "std::lerp(0.0, 100.0, 1.0) = " << std::lerp(0.0, 100.0, 1.0) << std::endl;  // 输出: 100
    
    // lerp 在 NaN/Infinity 情况下也能正确处理
    std::cout << "std::lerp with NaN: " << std::lerp(0.0, std::nan(""), 0.5) << std::endl;
    
    // 实用例子：颜色渐变
    // 从 RGB(255, 0, 0) 渐变到 RGB(0, 0, 255)，t=0.5 时应该是 (127, 0, 127)
    auto lerp_color = [](int r1, int g1, int b1, int r2, int g2, int b2, float t) {
        return std::lerp(r1, r2, t);
    };
    
    return 0;
}