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

#include <iostream>

// C++23: if consteval - 判断是否在常量求值上下文中
// constexpr函数允许在编译期或运行期求值（灵活版）
// 注意：如果你真的想让函数只能在编译期调用，使用consteval替代constexpr
constexpr void assertCompileTime() {
    // if consteval会在编译期判断当前是否处于常量求值上下文
    if consteval {
        // 如果在编译期求值，走到这里
        // 注意：从非constexpr上下文调用constexpr函数，这里不会执行
        std::cout << "Running at compile time" << std::endl;
    } else {
        // 如果在运行时求值，走到这里
        std::cout << "Running at runtime" << std::endl;
    }
}

int main() {
    // 调用constexpr函数，这里会在运行期求值
    // 因为是从非constexpr上下文调用的，所以会输出 "Running at runtime"
    assertCompileTime();
    
    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

#include <iostream>

// 模拟一个"智能"函数
consteval int factorial(int n) {
    if consteval {
        // 编译期：使用递推（更快）
        int result = 1;
        for (int i = 2; i <= n; ++i) {
            result *= i;
        }
        return result;
    } else {
        // 运行期：使用递归（更慢，但更"酷"）
        return n <= 1 ? 1 : n * factorial(n - 1);
    }
}

int main() {
    // 编译期计算！
    constexpr int fact5 = factorial(5);  // 120
    std::cout << "5! = " << fact5 << std::endl;  // 输出: 5! = 120
    
    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 <type_traits>

// C++20风格
constexpr int oldWay(int x) {
    if (std::is_constant_evaluated()) {
        return x * 2;
    } else {
        return x + 2;
    }
}

// C++23风格 - 更优雅！
consteval int newWay(int x) {
    if consteval {
        return x * 2;
    } else {
        return x + 2;
    }
}

int main() {
    constexpr int a = oldWay(10);  // 编译期: 20
    constexpr int b = newWay(10);  // 编译期: 20
    int c = oldWay(10);           // 运行期: 12
    
    std::cout << "oldWay编译期: " << a << std::endl;  // 输出: 20
    std::cout << "newWay编译期: " << b << std::endl;  // 输出: 20
    std::cout << "oldWay运行期: " << c << std::endl;  // 输出: 12
    
    return 0;
}

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

// 传统写法
struct Counter {
    int value = 0;
    void increment() {
        ++this->value;  // 隐式this
    }
};

// C++23显式对象参数写法
struct Counter {
    int value = 0;
    void increment(this Counter& self) {  // 显式声明"self"代表this
        ++self.value;  // 直接用self
    }
};

 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

#include <iostream>

struct Counter {
    int value = 0;
    
    // C++23: 显式对象参数
    // "this Counter& self" 意味着self是一个Counter引用
    void increment(this Counter& self) {
        ++self.value;
    }
    
    // 重载版本：const对象调用这个
    int get(this const Counter& self) {
        return self.value;
    }
};

int main() {
    Counter c;
    c.increment();  // 调用increment，self绑定到c
    
    std::cout << "Counter value: " << c.get() << std::endl;  // 输出: 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

#include <iostream>
#include <string>

structPrinter {
    // 使用显式对象参数打印任何东西
    void print(this auto& self, const std::string& msg) {
        std::cout << msg << std::endl;
    }
    
    // 链式调用！
    auto then(this auto& self, const std::string& msg) {
        std::cout << msg << std::endl;
        return self;  // 返回自身以便继续链式调用
    }
};

int main() {
    Printer p;
    p.print("Hello, C++23!");  // 输出: Hello, C++23!
    p.then("Step 1").then("Step 2").then("Step 3");  
    // 输出: Step 1
    // 输出: Step 2
    // 输出: Step 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

#include <iostream>

class Matrix {
    // 3x3矩阵，用一维数组存储
    int data_[9];
    
public:
    // C++23: 多维下标运算符
    // operator()可以接受多个参数
    int& operator()(int row, int col) {
        return data_[row * 3 + col];
    }
    
    const int& operator()(int row, int col) const {
        return data_[row * 3 + col];
    }
    
    // 打印矩阵（辅助函数）
    void print() const {
        std::cout << "Matrix:" << std::endl;
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                std::cout << (*this)(i, j) << " ";
            }
            std::cout << std::endl;
        }
    }
};

int main() {
    Matrix m;
    
    // 赋值
    m(0, 0) = 1;  m(0, 1) = 2;  m(0, 2) = 3;
    m(1, 0) = 4;  m(1, 1) = 5;  m(1, 2) = 6;
    m(2, 0) = 7;  m(2, 1) = 8;  m(2, 2) = 9;
    
    // 读取
    std::cout << "m(1,2) = " << m(1, 2) << std::endl;  // 输出: 6
    
    m.print();
    
    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 <vector>

class Tensor3D {
    std::vector<int> data_;
    int dim1_, dim2_, dim3_;
    
public:
    Tensor3D(int d1, int d2, int d3) 
        : dim1_(d1), dim2_(d2), dim3_(d3) {
        data_.resize(d1 * d2 * d3, 0);
    }
    
    // C++23: 三维下标运算符
    int& operator()(int i, int j, int k) {
        return data_[i * dim2_ * dim3_ + j * dim3_ + k];
    }
    
    const int& operator()(int i, int j, int k) const {
        return data_[i * dim2_ * dim3_ + j * dim3_ + k];
    }
};

int main() {
    Tensor3D t(2, 3, 4);  // 2x3x4的三维张量
    
    t(1, 2, 3) = 100;  // 设置一个值
    std::cout << "t(1,2,3) = " << t(1, 2, 3) << std::endl;  // 输出: 100
    
    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>

class Registry {
public:
    // 静态数据成员
    static int data[5];
    
    // C++23: 静态operator[]
    // 可以像数组一样用类名访问
    static int& operator[](int index) {
        return data[index];
    }
    
    // C++23: 静态operator()
    // 可以像函数一样用类名调用
    static int operator()(int x) {
        return x * x;
    }
};

// 初始化静态成员
int Registry::data[5] = {0, 10, 20, 30, 40};

int main() {
    // 用类名调用operator[]
    Registry[2] = 99;  // 不用创建实例！
    std::cout << "Registry[2] = " << Registry[2] << std::endl;  // 输出: 99
    
    // 用类名调用operator()
    std::cout << "Registry(7) = " << Registry(7) << std::endl;  // 输出: 49
    
    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 <cmath>

class MathUtils {
public:
    // 静态三角函数查表（假设已经预先计算好了）
    static double sin_table[360];
    
    // 静态operator[] - 查表获取sin值
    static double& operator[](int degrees) {
        // 简化示例：实际应该处理负数和大于360的情况
        int idx = ((degrees % 360) + 360) % 360;
        return sin_table[idx];
    }
    
    // 静态operator() - 计算sin值（使用实际数学运算）
    static double operator()(double radians) {
        return std::sin(radians);
    }
};

// 初始化sin表（简化版）
double MathUtils::sin_table[360] = {0};

int main() {
    MathUtils::sin_table[90] = 1.0;  // sin(90°) = 1
    MathUtils::sin_table[180] = 0.0;  // sin(180°) = 0
    
    std::cout << "sin(90°) via table = " << MathUtils[90] << std::endl;  // 输出: 1
    std::cout << "sin(PI/2) via func = " << MathUtils(3.14159/2) << std::endl;  // 约等于1
    
    return 0;
}

1
2
3
4
5
6

template<typename T>
void process(T&& arg) {
    // arg是一个转发引用，但我想保存一份副本
    // 以前：T copy = arg;  // 可能不对
    // 现在：auto copy = auto(arg);  // 完美！
}

 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 <vector>
#include <type_traits>

int main() {
    // C++23: auto(x) 和 auto{x} - decay-copy
    
    const int& ref = 42;  // ref是一个const int引用，绑定到临时int(42)
    
    // decay-copy：将引用"衰变"成实际值
    // auto(ref) 等价于: decay<decltype(ref)>(ref)
    auto copied = auto(ref);  // copied是int类型，值为42
    
    std::cout << "copied = " << copied << std::endl;  // 输出: copied = 42
    std::cout << "type is int: " << std::is_same_v<decltype(copied), int> << std::endl;  // 输出: 1
    
    // auto{x} 形式（列表初始化）
    auto copied2 = auto{ref};  // 同样是int，值为42
    
    std::cout << "copied2 = " << copied2 << std::endl;  // 输出: copied2 = 42
    
    // 对于vector也一样
    std::vector<int> vec{1, 2, 3};
    const std::vector<int>& vecRef = vec;
    
    // decay-copy成真正的vector
    auto vecCopy = auto(vecRef);  // vecCopy是std::vector<int>
    std::cout << "vecCopy size: " << vecCopy.size() << 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

#include <iostream>
#include <vector>

int main() {
    // auto(x) - 直接初始化，decay
    int arr[3] = {1, 2, 3};
    const int (&arrRef)[3] = arr;
    auto copied1 = auto(arrRef);  // const int*（decay-copy保留const）
    // 注意：数组会decay成指针，const属性也会保留！
    
    // auto{x} - 列表初始化
    // auto copied2 = auto{arrRef};  // 编译错误！不能列表初始化数组
    
    // 但对于类类型...
    std::vector<int> vec{1, 2, 3};
    const std::vector<int>& vecRef = vec;
    
    auto v1 = auto(vecRef);   // std::vector<int>
    auto v2 = auto{vecRef};   // std::vector<int>
    
    std::cout << "v1 size: " << v1.size() << std::endl;  // 输出: 3
    std::cout << "v2 size: " << v2.size() << 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

#include <iostream>
#include <memory>
#include <vector>

// 假设我们有一个返回引用的函数
std::vector<int>& getGlobalVector() {
    static std::vector<int> gvec{1, 2, 3};
    return gvec;
}

int main() {
    // 获取全局vector的引用
    std::vector<int>& ref = getGlobalVector();
    
    // 如果我们想创建一个独立的副本
    // 用auto(x)可以明确表达"我要复制并decay"
    auto copy = auto(ref);
    
    // 修改copy不影响原vector
    copy.push_back(4);
    
    std::cout << "Original size: " << ref.size() << std::endl;  // 输出: 3
    std::cout << "Copy size: " << copy.size() << std::endl;     // 输出: 4
    
    return 0;
}

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

#include <iostream>

int main() {
    // C++23: [[assume(expr)]] - 告诉编译器可以假设条件为真
    // 如果假设不成立，行为未定义（你死定了！）
    
    int x = 5;  // 运行时才知道值
    
    // 告诉编译器：假设x >= 0
    [[assume(x >= 0)]];
    
    // 编译器可能会优化掉下面的分支
    if (x < 0) {
        std::cout << "This should never print" << std::endl;
    }
    
    std::cout << "x = " << x << std::endl;  // 输出: x = 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

#include <iostream>
#include <vector>
#include <algorithm>

// 一个计算数组最大值的函数
int findMax(const std::vector<int>& arr) {
    // 假设数组不为空（调用者保证）
    [[assume(!arr.empty())]];
    
    int maxVal = arr[0];  // 如果数组为空，这行 UB！
    for (int i = 1; i < arr.size(); ++i) {
        maxVal = std::max(maxVal, arr[i]);
    }
    return maxVal;
}

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};
    std::cout << "Max: " << findMax(numbers) << std::endl;  // 输出: 9
    
    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

#include <iostream>

// 不安全：假设可能是错的
void unsafeFunction(int* ptr) {
    [[assume(ptr != nullptr)]];  // 如果ptr是nullptr，UB！
    *ptr = 42;  // 如果上面假设错了，程序崩溃
}

// 安全版本：先用assert检查
#include <cassert>
void safeFunction(int* ptr) {
    assert(ptr != nullptr && "ptr must not be null");
    [[assume(ptr != nullptr)]];  // 现在假设安全了
    *ptr = 42;
}

int main() {
    int x = 0;
    safeFunction(&x);
    std::cout << "x = " << x << std::endl;  // 输出: 42
    
    return 0;
}

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

// 在支持assume的编译器上
#if defined(__cpp_assume) && __cpp_assume >= 202302L
    #define ASSUME(expr) [[assume(expr)]]
#else
    // 回退到assert
    #define ASSUME(expr) assert(expr)
#endif

int optimizedAbs(int x) {
    ASSUME(x != INT_MIN);  // 避免INT_MIN取反溢出
    return x < 0 ? -x : x;
}

 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>

int main() {
    // C++23: Lambda可以有属性
    
    // 一个被标记为过时的Lambda
    [[deprecated("Use newLambda instead")]]
    auto oldLambda = [](int x) {
        return x * 2;
    };
    
    // 新的Lambda
    auto newLambda = [](int x) {
        return x * 3;
    };
    
    // 调用新版本
    std::cout << "newLambda(5) = " << newLambda(5) << std::endl;  // 输出: 15
    
    // 旧版本还能用，但会警告（MSVC特有语法，此处改为GCC/Clang兼容写法）
    #if defined(__GNUC__) || defined(__clang__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated"
    #endif
    std::cout << "oldLambda(5) = " << oldLambda(5) << std::endl;  // 输出: 10
    #if defined(__GNUC__) || defined(__clang__)
    #pragma GCC diagnostic pop
    #endif
    
    return 0;
}

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

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    // nodiscard Lambda - 返回值不应该被忽略
    [[nodiscard]]
    auto computeSum = [](const std::vector<int>& v) {
        return std::accumulate(v.begin(), v.end(), 0);
    };
    
    std::vector<int> nums{1, 2, 3, 4, 5};
    
    // 正确用法：捕获返回值
    int sum = computeSum(nums);  // nodiscard提醒你保存结果
    std::cout << "Sum: " << sum << std::endl;  // 输出: Sum: 15
    
    // 错误用法（如果有的话）：computeSum(nums); // 返回值被忽略，编译器可能警告
    
    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>

int main() {
    // 属性可以放在参数列表后面、函数体前面
    // C++23标准允许在Lambda上使用以下属性：
    
    // 1. [[nodiscard]]
    [[nodiscard]]
    auto createValue = [](int x) -> int {
        return x * x;
    };
    
    // 2. [[deprecated]]
    [[deprecated]]
    auto oldFunc = [](int x) {
        return x + 1;
    };
    
    // 3. [[likely]]
    auto checkEven = [](int x) {
        if (x % 2 == 0) [[likely]] {
            return "even";
        }
        return "odd";
    };
    
    std::cout << createValue(7) << std::endl;  // 输出: 49
    std::cout << checkEven(4) << std::endl;   // 输出: even
    
    return 0;
}

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

int main() {
    // C++23中，Lambda属性的位置比较灵活：
    
    // 位置1：Lambda前（给Lambda类型加属性）
    [[nodiscard]] auto lambda1 = [](int x) { return x; };
    
    // 位置2：mutable关键字后（给调用运算符加属性）
    auto lambda2 = [](int x) [[nodiscard]] { return x; };  // C++23
    // 注意：这是给operator()加属性
    
    // 位置3：尾置返回类型后
    auto lambda3 = [](int x) -> int [[nodiscard]] { return x; };  // C++23
    
    std::cout << lambda1(1) << lambda2(2) << lambda3(3) << 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

#include <iostream>
#include <cstdint>
#include <limits>
#include <cmath>

int main() {
    // C++23: 扩展浮点类型
    // 注意：需要编译器支持才能真正使用
    
    // 使用标准类型别名，明确指定精度
    std::float16_t half = 0.5f;        // 半精度
    std::float32_t single = 3.14f;      // 单精度
    std::float64_t double_ = 3.14159;  // 双精度
    std::bfloat16_t brain = 6.28f;     // bfloat16
    
    std::cout << "Half precision value: " << half << std::endl;
    std::cout << "Single precision value: " << single << std::endl;
    std::cout << "Double precision value: " << double_ << std::endl;
    std::cout << "Brain float value: " << brain << std::endl;
    
    // 检查类型是否存在
    std::cout << "\nType sizes:" << std::endl;
    std::cout << "sizeof(float16_t) = " << sizeof(std::float16_t) << " bytes" << std::endl;
    std::cout << "sizeof(float32_t) = " << sizeof(std::float32_t) << " bytes" << std::endl;
    std::cout << "sizeof(float64_t) = " << sizeof(std::float64_t) << " bytes" << std::endl;
    std::cout << "sizeof(bfloat16_t) = " << sizeof(std::bfloat16_t) << " bytes" << std::endl;
    
    return 0;
}

1
2
3
4
5

#if defined(FOO)
    // ...
#elif defined(BAR)
    // ...
#endif

1
2
3
4
5

#ifdef FOO
    // ...
#elifdef BAR  // C++23: elif if defined
    // ...
#endif

 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>

// C++23: 新的预处理器指令

// #elifdef: elif if defined (如果前面的#if/#elif不满足，检查这个是否定义)
// #elifndef: elif if not defined (如果前面的不满足，检查这个是否未定义)
// #warning: 产生一个编译警告

#define FEATURE_ENABLED
#define EXPERIMENTAL_MODE

int main() {
    // 传统写法
#if defined(DEBUG)
    std::cout << "Debug mode" << std::endl;
#elif defined(FEATURE_ENABLED)
    std::cout << "Feature enabled" << std::endl;  // 这行会被执行
#else
    std::cout << "Default mode" << std::endl;
#endif
    
    // C++23新写法 - 更直观！
#ifdef DEBUG
    std::cout << "Debug mode" << std::endl;
#elifdef FEATURE_ENABLED  // C++23: elifdef
    std::cout << "Feature enabled (new syntax)" << std::endl;  // 这行会被执行
#endif
    
#ifndef OBSOLETE_API  // C++23: if not defined
    std::cout << "Using modern API" << std::endl;
#endif
    
    return 0;
}

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

#include <iostream>

#define LEGACY_CODE

int main() {
    // 发出警告
    #warning "This code is using deprecated patterns!"
    
    #ifdef LEGACY_CODE
    #warning "LEGACY_CODE is defined, consider removing it"
    #endif
    
    std::cout << "Hello, C++23 preprocessor!" << 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

#include <iostream>

// 检测编译器的C++标准版本
#if __cplusplus >= 202302L
    #define IS_CPP23 1
#else
    #define IS_CPP23 0
#endif

#if IS_CPP23
    #warning "Compiled with C++23! Welcome to the future!"
#else
    #warning "Not C++23. Some features may not be available."
#endif

int main() {
    std::cout << "C++ standard: " << __cplusplus << std::endl;
    
    #if IS_CPP23
    std::cout << "Using C++23 features!" << std::endl;
    #endif
    
    return 0;
}

1
2

size_t len = 100;  // 需要强制转换
size_t len = static_cast<size_t>(100);  // 或者用static_cast

 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 <cstddef>
#include <vector>
#include <format>

int main() {
    // C++23: size_t字面量后缀
    // z或Z后缀表示size_t类型
    
    size_t len1 = 100z;   // 使用z后缀
    size_t len2 = 200Z;   // 使用Z后缀（大写也行）
    
    std::cout << "len1 = " << len1 << std::endl;  // 输出: 100
    std::cout << "len2 = " << len2 << std::endl;  // 输出: 200
    
    // 以前需要这样写：
    // size_t len_old = 100;  // 可能警告：精度丢失
    // size_t len_cast = static_cast<size_t>(100);  // 太繁琐
    
    // 数组大小也可以用
    int arr[50z];  // 50是size_t类型
    std::cout << "Array size: " << (sizeof(arr) / sizeof(arr[0])) << std::endl;  // 输出: 50
    
    // 在泛型编程中特别有用
    auto vec = std::vector<int>(100z);  // 100是size_t
    std::cout << "Vector size: " << vec.size() << std::endl;  // 输出: 100
    
    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 <cstddef>
#include <vector>

// 模板函数：创建一个包含n个元素的vector
template<typename T>
std::vector<T> createVector(size_t n, T val) {
    return std::vector<T>(n, val);
}

int main() {
    // C++23之前：需要静态转换
    // auto v1 = createVector(static_cast<size_t>(100), 42);
    
    // C++23：直接写100z
    auto v1 = createVector(100z, 42);
    auto v2 = createVector(50z, 3.14);
    
    std::cout << "v1.size() = " << v1.size() << std::endl;  // 输出: 100
    std::cout << "v2.size() = " << v2.size() << std::endl;  // 输出: 50
    
    // 用于索引
    std::string s = "Hello, C++23!";
    size_t idx = 7z;  // 明确是size_t类型
    std::cout << "s[" << idx << "] = " << s[idx] << std::endl;  // 输出: C
    
    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 <string>
#include <string_view>

// C++23: trim系列函数（非成员函数，使用string_view）
int main() {
    // C++23: 新的字符串修剪操作（使用std::ranges::trim或手动实现）
    
    std::string s = "   Hello, C++23!   ";
    
    // C++23中trim是ranges算法，这里演示手动实现的效果
    // 实际使用可以用 std::ranges::trim(s) 返回一个视图
    auto trimmed = [](std::string_view sv) -> std::string {
        size_t start = sv.find_first_not_of(" \t\n\r");
        size_t end = sv.find_last_not_of(" \t\n\r");
        if (start == std::string_view::npos) return "";
        return std::string(sv.substr(start, end - start + 1));
    };
    
    std::string_view sv = s;
    std::string trimmedStr = trimmed(sv);
    
    std::cout << "Original: '" << s << "'" << std::endl;
    std::cout << "Trimmed: '" << trimmedStr << "'" << std::endl;
    
    return 0;
}

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

#include <iostream>

int main() {
    // C++23改进了行拼接的说明，实际上自C++11起\后面就可以有空白
    auto message = "Hello, " \
                   "C++23!";
    
    std::cout << message << std::endl;  // 输出: Hello, C++23!
    
    // 使用续行符连接多行字符串
    auto poem = "床前明月光，\
                疑是地上霜。\
                举头望明月，\
                低头思故乡。";
    
    std::cout << poem << 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

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

int main() {
    // 处理用户输入（去除首尾空白）
    std::vector<std::string> inputs = {
        "   Alice",
        "Bob   ",
        "  Charlie  ",
        "   Dave   "
    };
    
    std::cout << "Before and after trim:" << std::endl;
    // trim辅助函数（C++23风格的手动实现）
    auto trim = [](std::string_view sv) -> std::string {
        size_t start = sv.find_first_not_of(" \t\n\r");
        size_t end = sv.find_last_not_of(" \t\n\r");
        if (start == std::string_view::npos) return "";
        return std::string(sv.substr(start, end - start + 1));
    };
    for (const auto& name : inputs) {
        std::string original = name;
        std::string trimmed = trim(name);
        std::cout << "'" << original << "' -> '" << trimmed << "'" << std::endl;
    }
    
    // 处理CSV数据
    std::string csvLine = "  123, 456, 789  ";
    std::cout << "CSV trimmed: '" << trim(csvLine) << "'" << std::endl;
    
    return 0;
}

1
2
3
4

std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    return v;  // C++98/03：拷贝整个vector
}

1

return v;  // 移动而不是拷贝

 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

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

// 模拟一个会产生移动的函数
std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    return v;  // C++17：强制拷贝省略（C++17起）
}

class MyClass {
public:
    std::vector<int> data;
    
    MyClass() {
        std::cout << "  MyClass constructed" << std::endl;
    }
    
    ~MyClass() {
        std::cout << "  MyClass destroyed" << std::endl;
    }
    
    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(std::move(other.data)) {
        std::cout << "  MyClass moved" << std::endl;
    }
    
    // 拷贝构造函数
    MyClass(const MyClass& other) : data(other.data) {
        std::cout << "  MyClass copied" << std::endl;
    }
};

MyClass createMyClass() {
    MyClass m;
    return m;  // C++17保证不会调用拷贝/移动
}

int main() {
    // C++23进一步简化隐式移动规则
    std::cout << "Creating vector:" << std::endl;
    auto v = createVector();
    std::cout << "v.size() = " << v.size() << std::endl;  // 输出: 3
    
    std::cout << "\nCreating MyClass:" << std::endl;
    auto m = createMyClass();  // C++17保证零拷贝/移动
    
    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

#include <iostream>
#include <memory>

struct BigObject {
    int data[1000];
    BigObject() { std::cout << "  BigObject constructed" << std::endl; }
    ~BigObject() { std::cout << "  BigObject destroyed" << std::endl; }
};

// C++23更宽松的隐式移动规则影响
BigObject createObject() {
    BigObject obj;
    // ... 可能有一些操作 ...
    return obj;  // C++23保证不会有多余的拷贝
}

int main() {
    std::cout << "Creating BigObject:" << std::endl;
    auto obj = createObject();
    std::cout << "Object created successfully" << std::endl;
    
    return 0;
}

1
2
3
4

std::vector<int> v{1, 2, 3};
for (int x : v) {
    std::cout << x << " ";
}

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

#include <iostream>
#include <vector>

int main() {
    // C++23: 范围for可以有初始化器
    // 初始化器和循环变量可以在同一个for语句中声明
    
    for (auto vec = std::vector{1, 2, 3}; auto& v : vec) {
        std::cout << v << " ";
    }
    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

#include <iostream>
#include <vector>
#include <map>

int main() {
    // 场景1：过滤并处理
    std::cout << "Even numbers:" << std::endl;
    for (auto vec = std::vector{1, 2, 3, 4, 5, 6}; const auto& v : vec) {
        if (v % 2 == 0) {
            std::cout << v << " ";  // 输出: 2 4 6
        }
    }
    std::cout << std::endl;
    
    // 场景2：与if一起使用
    for (auto m = std::map<std::string, int>{{"a", 1}, {"b", 2}}; 
         const auto& [key, value] : m) {
        std::cout << key << "=" << value << " ";  // 输出: a=1 b=2
    }
    std::cout << std::endl;
    
    // 场景3：临时对象的生命周期
    for (auto p = std::pair{1, 2}; const auto& elem : 
         {p.first, p.second, p.first + p.second}) {
        std::cout << elem << " ";  // 输出: 1 2 3
    }
    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

#include <iostream>
#include <vector>

int main() {
    // 语法：for (初始化器; 循环变量声明; 循环体)
    
    // 初始化器可以是任何表达式
    for (auto counter = 0; const auto& x : {1, 2, 3, 4, 5}) {
        std::cout << counter++ << ":" << x << " ";
    }
    std::cout << std::endl;
    // 输出: 0:1 1:2 2:3 3:4 4:5
    
    // 初始化器中声明的变量作用域是整个for语句
    for (auto result = 0; const auto& x : {10, 20, 30}) {
        result += x;
    }
    // result在这里仍然可见
    // std::cout << result << std::endl;  // 注释：这里输出60
    
    return 0;
}

1

std::vector v{1, 2, 3};  // 编译器推导出std::vector<int>

 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