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 main() {
    // std::pair：存储两个异构对象的容器
    // 想象一下：这就像是一张火车票——座位号和乘客名
    std::pair<int, std::string> p1(1, "one");  // 传统写法
    std::pair p2{2, "two"};  // C++17 CTAD，编译器自动推断类型，偷懒神器！

    std::cout << "p1: (" << p1.first << ", " << p1.second << ")" << std::endl;
    // 输出: p1: (1, one)

    // 比较操作——字典序比较，先比first，再比second
    // 就像按姓氏排序电话本，先看姓再看名
    std::pair<int, int> a(1, 2);
    std::pair<int, int> b(1, 3);

    std::cout << "(1,2) < (1,3): " << (a < b) << std::endl;  // 输出: 1 (true)
    // 因为first相等(1==1)，所以比较second，2 < 3，所以a < b

    // make_pair便捷函数——不用写类型，编译器帮你猜
    auto p3 = std::make_pair(3, "three");

    // 结构化绑定（C++17）——这是史诗级特性！
    // 想象一下拆快递：不用先打开再看里面是什么，直接一次性拆开验货
    auto [num, str] = p1;
    std::cout << "num=" << num << ", str=" << str << std::endl;  // 输出: num=1, str=one

    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 <tuple>
#include <string>

int main() {
    // std::tuple：存储多个异构对象的容器
    // 想象一下：tuple就像是一个多功能的工具箱，里面可以有锤子、螺丝刀、香蕉
    std::tuple<int, double, std::string, char> t(1, 3.14, "hello", 'c');

    // 访问元素——必须用编译时索引，像是在问"第0个抽屉里是什么？"
    std::cout << "get<0>: " << std::get<0>(t) << std::endl;  // 输出: 1
    std::cout << "get<2>: " << std::get<2>(t) << std::endl;  // 输出: hello
    // 注意：get的模板参数必须是常量表达式，get<变量>是不行的！

    // 结构化绑定（C++17）——拆快递神器升级版！
    auto [i, d, s, c] = t;  // i=1, d=3.14, s="hello", c='c'
    std::cout << "i=" << i << ", d=" << d << ", s=" << s << std::endl;
    // 输出: i=1, d=3.14, s=hello

    // 比较（字典序）——和pair一样的比较规则
    std::tuple<int, int> t1(1, 2);
    std::tuple<int, int> t2(1, 3);
    std::cout << "(1,2) < (1,3): " << (t1 < t2) << std::endl;  // 输出: 1
    // t1和t2的first都是1，相等；然后比较second，2 < 3

    // 链接两个tuple——把两个tuple焊接在一起！
    auto t3 = std::tuple_cat(t1, std::make_tuple(3));
    // t3现在有3个元素：(1, 2, 3)
    std::cout << "Concatenated tuple size: " << std::tuple_size<decltype(t3)>::value << std::endl;
    // 输出: Concatenated tuple size: 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

#include <iostream>
#include <tuple>

// 选择tuple的场景：
// - 快速原型，不需要命名（"我只是想临时打包几个值，别让我取名字！"）
// - 返回多个值（函数返回值不够用？tuple来凑！）
// - 作为map的键（需要异构键的时候）
// - 泛型代码（模板元编程里tuple是常客）

// 选择struct的场景：
// - 需要清晰的语义命名（Point3D比tuple<double,double,double>好理解一万倍）
// - 需要文档说明（成员变量名就是最好的注释）
// - 代码可读性更重要（团队合作时struct更友好）
// - 需要稳定ABI（struct的内存布局是确定的，tuple可不一定）
// - 需要成员函数（struct可以有方法！）

struct Point3D {
    double x, y, z;  // 这三个字母胜过千言万语
};

int main() {
    // tuple适合快速返回多个值——就像点外卖不需要知道厨房怎么运作
    std::tuple<int, int, int> getRGB() {
        return {255, 128, 64};  // 橙色的RGB值
    }

    auto [r, g, b] = getRGB();  // 结构化绑定直接拆包
    std::cout << "RGB: " << r << "," << g << "," << b << std::endl;
    // 输出: RGB: 255,128,64

    // struct适合需要清晰命名的情况——就像家里的调料盒
    Point3D p{1.0, 2.0, 3.0};
    std::cout << "Point: (" << p.x << "," << p.y << "," << p.z << ")" << std::endl;
    // 输出: Point: (1,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
41
42
43
44
45
46

#include <iostream>
#include <optional>
#include <string>

// 在字符串中查找字符，返回索引（如果找到）或空optional
std::optional<int> findIndex(const std::string& str, char target) {
    for (int i = 0; i < static_cast<int>(str.size()); ++i) {
        if (str[i] == target) {
            return i;  // 隐式构造optional，相当于 std::optional<int>(i)
        }
    }
    return std::nullopt;  // 明确表示"没有值"
}

int main() {
    // std::optional：表示"可能有值"的类型
    // 替代方案们：返回特殊值（-1表示没找到）、返回指针、抛出异常
    // optional比这些方案都更语义化——代码读起来就知道"可能有，可能没有"

    auto index = findIndex("hello", 'l');  // 'l'在索引2和3的位置，但只返回第一个

    // 方法1：has_value() + value()
    if (index.has_value()) {
        std::cout << "Found at index: " << index.value() << std::endl;
        // 输出: Found at index: 2
    } else {
        std::cout << "Not found" << std::endl;
    }

    // 方法2：value_or()——如果有值就用，没有就给默认值
    // 这就像是"如果冰箱里有啤酒就喝啤酒，否则喝可乐"
    int result = index.value_or(-1);
    std::cout << "Result with default: " << result << std::endl;  // 输出: 2

    // 找不存在的字符
    auto notFound = findIndex("hello", 'z');
    std::cout << "Not found value_or: " << notFound.value_or(-1) << std::endl;
    // 输出: -1（因为没找到，所以用默认值-1）

    // 方法3：直接当bool用——这是最简洁的写法
    if (auto idx = findIndex("world", 'o')) {  // 'o'在索引1
        std::cout << "Found 'o' at " << *idx << std::endl;  // 输出: Found 'o' at 1
    }

    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

#include <iostream>
#include <optional>

int main() {
    // C++23: optional的单态操作（monadic operations）
    // 想象一下：这些操作就像是optional的"变形金刚"，可以连续变身

    std::cout << "C++23 optional monadic operations:" << std::endl;

    std::optional<int> opt = 42;

    // map: 转换值——如果有值，就对它进行转换
    // opt.map([](int x) { return x * 2; });  // 若opt有值42，结果为optional<int>(84)

    // transform: 类似map但更灵活
    // std::transform(opt, [](int x) { return x * 2; });

    // and_then: 链式操作——如果都有值，就继续执行
    // opt.and_then([](int x) { return std::optional<int>(x * 2); });

    // or_else: 提供默认值——如果没有值，执行这个 lambda
    // opt.or_else([] { return std::optional<int>(0); });

    std::cout << "std::optional has map/and_then/transform/or_else 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
36
37
38

#include <iostream>
#include <optional>

// optional vs 指针的选择：
// ┌─────────────────┬────────────────────────┐
//│    optional     │         指针            │
// ├─────────────────┼────────────────────────┤
//│ 值语义，不涉及   │ 指向外部对象，可能被    │
//│ 所有权问题       │ 别人修改或释放           │
//│ 语义更清晰：     │ 语义模糊：              │
//│ "可能有值"       │ "可能指向某物"或"没有   │
//│                 │ 指向"                   │
//│ 适合返回值       │ 适合输入参数（out参数）  │
//│ 不能重新绑定     │ 可以重新指向别的对象     │
//└─────────────────┴────────────────────────┘

// 解析字符串为整数——成功返回数字，失败返回空optional
std::optional<int> parseInt(const std::string& s) {
    try {
        return std::stoi(s);  // 成功，包装成optional
    } catch (...) {
        return std::nullopt;  // 失败，返回空
    }
}

int main() {
    auto val = parseInt("123");
    if (val) {
        std::cout << "Parsed: " << *val << std::endl;  // 输出: Parsed: 123
    }

    auto invalid = parseInt("not a number");
    if (!invalid) {
        std::cout << "Failed to parse" << std::endl;  // 输出: Failed to parse
    }

    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 <variant>
#include <string>

int main() {
    // std::variant：类型安全的联合体
    // 想象一下：这就像是一个神奇的盒子，可以装任何东西，但同一时间只能装一种
    // 而且每次打开盒子，盒子都会告诉你里面装的是什么

    std::variant<int, double, std::string> v;  // 可以是int、double或string

    v = 42;  // 现在装的是int
    std::cout << "int variant: " << std::get<int>(v) << std::endl;  // 输出: 42

    v = 3.14;  // 现在装的是double
    std::cout << "double variant: " << std::get<double>(v) << std::endl;  // 输出: 3.14

    v = "hello";  // 现在装的是string
    std::cout << "string variant: " << std::get<std::string>(v) << std::endl;  // 输出: hello

    // 检查当前类型——就像问"你现在是人格几？"
    if (std::holds_alternative<std::string>(v)) {
        std::cout << "Variant holds a string" << std::endl;
        // 输出: Variant holds a string
    }

    // 尝试安全获取——如果类型不对，返回nullptr而不是抛异常
    if (auto* str = std::get_if<std::string>(&v)) {
        std::cout << "Got string: " << *str << std::endl;
        // 输出: Got string: hello
    }

    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 <variant>

int main() {
    std::variant<int, double, char> v = 100;  // 当前类型是int，值是100

    // std::get: 直接访问——如果类型对，拿值；如果类型错，抛异常
    // 就像用钥匙开门，错了就报警
    try {
        int val = std::get<int>(v);
        std::cout << "std::get<int>: " << val << std::endl;  // 输出: 100

        // 如果你想看double？门都没有！
        // std::get<double>(v);  // 抛 std::bad_variant_access 异常！
    } catch (const std::bad_variant_access& e) {
        std::cout << "Wrong type! Variant doesn't hold a double." << std::endl;
    }

    // std::get_if: 安全访问——如果类型对，返回指针；如果类型错，返回nullptr
    // 就像门禁卡，不对就安静地告诉你"没权限"
    if (auto* ptr = std::get_if<int>(&v)) {
        std::cout << "std::get_if<int>: " << *ptr << std::endl;  // 输出: 100
    }

    // 尝试获取double类型——返回nullptr
    if (auto* ptr = std::get_if<double>(&v)) {
        std::cout << "Should not reach here" << std::endl;
    } else {
        std::cout << "std::get_if<double>: nullptr (wrong type)" << std::endl;
        // 输出: std::get_if<double>: nullptr (wrong type)
    }

    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 <any>
#include <string>

int main() {
    // std::any：类型擦除的容器，可以存储任意类型
    // 就像一个神奇的垃圾桶，什么都能扔进去，但取出来时得知道原来是什么

    std::any a = 42;              // 扔进去一个int
    std::any b = 3.14;            // 扔进去一个double
    std::any c = std::string("hello");  // 扔进去一个string

    // std::any_cast 提取值——必须知道原来是什么类型！
    // 方式1：指针版本，类型错了返回nullptr
    int* intPtr = std::any_cast<int>(&a);
    if (intPtr) {
        std::cout << "any_cast<int>: " << *intPtr << std::endl;  // 输出: 42
    }

    // 方式2：值版本，类型错了抛 std::bad_any_cast 异常
    int val = std::any_cast<int>(a);
    std::cout << "any_cast<int>(a): " << val << std::endl;  // 输出: 42

    // 如果你记错了类型……那就尴尬了
    try {
        double d = std::any_cast<double>(a);  // a实际上是int，抛异常！
    } catch (const std::bad_any_cast& e) {
        std::cout << "bad_any_cast caught! You lied about the type." << std::endl;
    }

    // 检查有没有值
    std::any empty;
    std::cout << "empty.has_value(): " << empty.has_value() << std::endl;  // 输出: 0

    // reset——扔掉里面的东西
    a.reset();
    std::cout << "After reset, a.has_value(): " << a.has_value() << std::endl;  // 输出: 0

    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 <any>
#include <chrono>

int main() {
    // std::any的性能考虑：
    // ┌──────────────────────────────────────────────────────────────┐
    //│                      any 的 缺 点                              │
    // ├──────────────────────────────────────────────────────────────┤
    //│ 1. 堆分配：如果存的东西比较大（比如大字符串、vector），          │
    //│    需要在堆上分配内存，小东西可能有 SSO（短字符串优化）         │
    //│                                                              │
    //│ 2. 类型信息存储：any要记录"你原来是什么类型"，有额外开销        │
    //│                                                              │
    //│ 3. 类型检查：any_cast时要做运行时类型检查，比静态类型转换慢       │
    //│                                                              │
    //│ 4. 无法内联：因为类型擦除，编译器很难内联优化                   │
    //└──────────────────────────────────────────────────────────────┘

    std::cout << "std::any performance considerations:" << std::endl;
    std::cout << "- Small Object Optimization: typically small objects stored inline" << std::endl;
    std::cout << "- Type erasure overhead" << std::endl;
    std::cout << "- Runtime type checking" << std::endl;
    std::cout << "- Hard to optimize (no static type info)" << std::endl;

    // 什么时候用 any vs variant？
    // - 已知所有可能的类型 → 用 variant（类型安全+无额外开销）
    // - 类型完全未知/动态 → 用 any（灵活性至上）
    // - 已知类型，但很多/不想用模板 → 用 any

    return 0;
}

1
2
3
4
5
6
7

std::optional<int> parseNumber(const std::string& s) {
    try {
        return std::stoi(s);
    } catch (...) {
        return std::nullopt;  // 失败了就返回"什么都没有"
    }
}

 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

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

// C++23: std::expected 表示"可能成功返回某值，或失败返回错误"
// 模板参数：第一个是成功值的类型，第二个是错误类型
// std::expected<int, std::string> 表示：成功返回int，失败返回string错误信息

std::expected<int, std::string> parseNumber(const std::string& s) {
    try {
        return std::stoi(s);  // 成功，返回值
    } catch (...) {
        // 失败，返回错误原因
        return std::unexpected("Failed to parse: " + s);
    }
}

int main() {
    // 成功的例子
    auto result1 = parseNumber("42");
    if (result1) {  // expected可以当bool用
        std::cout << "Parsed: " << result1.value() << std::endl;
        // 输出: Parsed: 42
    }

    // 失败的例子
    auto result2 = parseNumber("not a number");
    if (!result2) {
        std::cout << "Error: " << result2.error() << std::endl;
        // 输出: Error: Failed to parse: not a number
    }

    // value_or的替代方案——用value_or提供默认值
    int withDefault = result2.value_or(0);
    std::cout << "With default: " << withDefault << std::endl;
    // 输出: With default: 0

    return 0;
}

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

#include <iostream>
#include <expected>

int main() {
    // C++23: expected的单态操作
    // 和optional一样的链式操作能力，但专门为错误处理设计

    std::cout << "C++23 expected monadic operations:" << std::endl;
    std::cout << "- and_then: 链式操作，成功就继续，失败就传递错误" << std::endl;
    std::cout << "- map: 转换值，成功时对值做转换" << std::endl;
    std::cout << "- transform: 类似map但更灵活" << std::endl;
    std::cout << "- or_else: 失败时提供替代的expected" << std::endl;

    // 使用场景示例：
    // auto result = parseNumber("42")
    //     .and_then([](int n) { return validate(n); })
    //     .map([](int n) { return n * 2; });

    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

#include <iostream>
#include <bitset>

int main() {
    // std::bitset：固定大小的位序列
    // 模板参数是位数，一旦定义就不能改变（和array一样）
    // 适合做标志位、掩码、集合等

    std::bitset<8> bits(0b10110011);  // 8位，初始值二进制10110011

    std::cout << "bits: " << bits << std::endl;  // 输出: 10110011

    // 位运算——和整数位运算一样，但结果是bitset
    std::cout << "bits << 2: " << (bits << 2) << std::endl;  // 输出: 11001100
    std::cout << "bits | 0b00001111: " << (bits | 0b00001111) << std::endl;
    // 输出: 10111111

    // 测试和设置位
    std::cout << "bits[0]: " << bits[0] << std::endl;  // 输出: 1（最后一位）
    std::cout << "bits.test(1): " << bits.test(1) << std::endl;  // 输出: 1（第二位）
    std::cout << "bits.all(): " << bits.all() << std::endl;  // 输出: 0（不是全1）
    std::cout << "bits.any(): " << bits.any() << std::endl;  // 输出: 1（有1存在）

    // 设置和翻转
    bits.set(0, 0);  // 设置第0位为0
    bits.flip();     // 所有位取反
    // 10110011 → set(0,0) → 10110010 → flip → 01001101
    std::cout << "After set(0,0) and flip: " << bits << std::endl;  // 输出: 01001101

    return 0;
}

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

#include <iostream>
#include <bit>

int main() {
    // C++23: std::byteswap 交换字节序
    // 就像是把乐高块的顺序反过来拼

    unsigned int value = 0x12345678;  // 假设这是小端序
    auto swapped = std::byteswap(value);  // 变成大端序

    std::cout << "Original: 0x" << std::hex << value << std::endl;  // 输出: Original: 0x12345678
    std::cout << "Swapped: 0x" << swapped << std::endl;            // 输出: Swapped: 0x78563412

    // 典型应用：
    // - 网络编程：发送数据前转换字节序
    // - 文件格式：有些文件格式要求特定字节序
    // - 序列化/反序列化：和外部系统交互时

    return 0;
}

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

#include <iostream>
#include <type_traits>

// 强类型枚举（enum class）不会隐式转换为int
enum class Color : int { Red = 1, Green = 2, Blue = 3 };

int main() {
    // C++23: std::to_underlying 获取枚举的底层整数值
    // 就像是给强类型枚举"脱马甲"，露出真面目

    Color c = Color::Green;
    int underlying = std::to_underlying(c);  // C++23之前需要 static_cast<int>(c)

    std::cout << "to_underlying(Color::Green) = " << underlying << std::endl;
    // 输出: 2

    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 <utility>

void switchExample(int value) {
    switch (value) {
        case 1:
            std::cout << "One" << std::endl;
            break;
        case 2:
            std::cout << "Two" << std::endl;
            break;
        default:
            // 如果我们知道value只可能是1或2，那default永远不会到
            // 用 std::unreachable() 告诉编译器这一点
            std::unreachable();  // C++23: 告诉编译器这行不会执行
    }
}

int main() {
    switchExample(1);  // 输出: One

    std::cout << "std::unreachable tells compiler this code is unreachable" << std::endl;

    // 注意：如果误用了 unreachable，比如实际上会执行到那里
    // 行为是未定义的（undefined behavior）！
    // 所以用之前一定要确保真的不会执行到

    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 <chrono>
#include <thread>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;  // 启用时间字面量（1s, 90s, 100ms等）

    // ┌─────────────────────────────────────────────────────────────┐
    //│                    时间段 (duration)                          │
    //│  就像一个苹果，可以是"1个苹果"，也可以是"半个苹果"              │
    //└─────────────────────────────────────────────────────────────┘

    duration<int> seconds(5);                              // 5秒
    duration<double, std::milli> milliseconds(100.5);      // 100.5毫秒

    std::cout << "seconds.count(): " << seconds.count() << std::endl;  // 输出: 5
    std::cout << "milliseconds.count(): " << milliseconds.count() << std::endl;  // 输出: 100.5

    // ┌─────────────────────────────────────────────────────────────┐
    //│                    时间点 (time point)                        │
    //│  就像日历上的一个具体日期                                       │
    //└─────────────────────────────────────────────────────────────┘

    auto now = system_clock::now();  // 获取当前时刻
    auto later = now + 1s;          // 加1秒（C++14的字面量）

    // ┌─────────────────────────────────────────────────────────────┐
    //│                    duration_cast                              │
    //│  转换时间单位，就像换算货币                                      │
    //└─────────────────────────────────────────────────────────────┘

    auto mins = duration_cast<minutes>(90s);  // 把90秒转换成分钟（90s = 1.5min，向下取整得1）
    std::cout << "90 seconds = " << mins.count() << " minutes" << std::endl;  // 输出: 1

    // ┌─────────────────────────────────────────────────────────────┐
    //│                    时间字面量 (C++14)                          │
    //│  10h, 5min, 3s, 100ms, 50us, 7ns                               │
    //└─────────────────────────────────────────────────────────────┘

    auto delay = 100ms;  // 100毫秒
    std::cout << "delay = " << delay.count() << " ms" << std::endl;  // 输出: 100

    // ┌─────────────────────────────────────────────────────────────┐
    //│                    睡眠                                        │
    //│  让程序"睡一会"，就像你午休一样                                  │
    //└─────────────────────────────────────────────────────────────┘

    std::cout << "Sleeping for 10ms..." << std::endl;
    std::this_thread::sleep_for(10ms);  // 睡眠10毫秒
    std::cout << "Awake!" << 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // ┌─────────────────────────────────────────────────────────────┐
    //│                system_clock: 系统实时时钟                      │
    //│  用途：获取当前时间，转换成日历时间                              │
    //│  特点：可以回拨（系统时间调整时），不适合测量时间间隔             │
    //└─────────────────────────────────────────────────────────────┘

    auto sys_now = std::chrono::system_clock::now();
    std::time_t sys_time = std::chrono::system_clock::to_time_t(sys_now);
    std::cout << "System time: " << std::ctime(&sys_time) << std::endl;

    // ┌─────────────────────────────────────────────────────────────┐
    //│                steady_clock: 单调时钟                          │
    //│  用途：测量时间间隔                                             │
    //│  特点：时间只往前走，不会回拨，保证测量准确性                    │
    //│  推荐：测量时间间隔时用这个！                                    │
    //└─────────────────────────────────────────────────────────────┘

    auto steady_now = std::chrono::steady_clock::now();

    // ┌─────────────────────────────────────────────────────────────┐
    //│                high_resolution_clock: 高精度时钟              │
    //│  用途：需要最高精度时                                            │
    //│  特点：可能是 system_clock 或 steady_clock 的别名              │
    //│  注意：别依赖它的稳定性，steady_clock更可靠                     │
    //└─────────────────────────────────────────────────────────────┘

    auto hr_now = std::chrono::high_resolution_clock::now();

    // ┌─────────────────────────────────────────────────────────────┐
    //│                实战：测量代码执行时间                          │
    //└─────────────────────────────────────────────────────────────┘

    auto start = steady_clock::now();  // 开始计时

    long long sum = 0;
    for (int i = 0; i < 1000000; ++i) sum += i;  // 干点活

    auto end = steady_clock::now();    // 结束计时
    auto elapsed = duration_cast<microseconds>(end - start);  // 计算差值

    std::cout << "Sum: " << sum << ", Time: " << elapsed.count() << " us" << std::endl;
    // 输出: Sum: 499999500000, Time: xxx us（取决于CPU）

    return 0;
}