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>

struct Printer {
    // 使用显式对象参数打印任何东西
    void print(this auto& self, const std::string& msg) {
        std::cout << msg << std::endl;
    }
    
    // 链式调用！
    auto& then(this auto& self, const std::string& msg) {   // 注意返回类型要写成 auto&
        std::cout << msg << std::endl;
        return self;  // auto 会丢掉引用，写成 auto& 才能真正"返回自身"
    }
};

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

struct Registry {
    static int& operator[](int i);
    static int operator()(int x) { return x * x; }
};

Registry[2];   // ❌ error: 'Registry' does not refer to a value
Registry(7);   // ❌ error: no matching conversion for functional-style cast from 'int' to 'Registry'

1
2
3

Registry::operator[](2);   // 方式1：限定名直接调用（最清楚）
Registry r;
r[2];                      // 方式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

#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() {
    // 方式1：限定名调用
    Registry::operator[](2) = 99;
    std::cout << "Registry::operator[](2) = " << Registry::operator[](2) << '\n';  // 99

    // 方式2：通过对象调用（静态成员运算符允许用对象调用）
    Registry r;
    std::cout << "r[1] = " << r[1] << '\n';   // 10
    std::cout << "r(7) = " << r(7) << '\n';   // 49

    // 下面两行是编译错误，留在这里是为了提醒你
    // Registry[2];   // error: 'Registry' does not refer to a value
    // Registry(7);   // error: no matching conversion ... to 'Registry'
}

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

int main() {
    // 位置1：写在变量声明前 —— 属性贴在"变量"上
    [[deprecated("use newLambda instead")]]
    auto oldLambda = [](int x) { return x * 2; };
    oldLambda(5);   // ⚠️ warning: 'oldLambda' is deprecated
                    //    这个位置对 [[deprecated]] 是有效的

    // 位置2：写在 lambda-introducer 之后、参数列表之前（C++23 新增的位置）
    auto l2 = [] [[nodiscard]] (int x) { return x + 1; };
    l2(2);          // 语法通过，而且不会报警……
                    // 也就是说：这个属性并没有让"返回值检查"生效
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

auto l3 = [](int x) [[nodiscard]] { return x; };
// error: 'nodiscard' attribute cannot be applied to types

auto l4 = [](int x) -> int [[nodiscard]] { return x; };
// error: 'nodiscard' attribute cannot be applied to types

[[nodiscard]] auto l5 = [](int x) { return x + 1; };
// warning: 'nodiscard' attribute only applies to Objective-C methods, enums,
//          structs, unions, classes, functions, function pointers, and typedefs
//          [-Wignored-attributes]
// 属性贴在了变量 l5 上，被忽略；调用 l5(2) 丢掉返回值也不会报警

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

#include <iostream>

struct Square {
    [[nodiscard]] int operator()(int x) const { return x * x; }
};

int main() {
    Square sq;
    std::cout << sq(3) << '\n';   // 9
    sq(3);                        // ⚠️ warning: ignoring return value of function
                                  //    declared with 'nodiscard' attribute
}

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

#include <cstdint>
#include <cstdio>
#include <limits>

int main() {
    // ① 标准化的"扩展浮点类型"定义在 <stdfloat> 里（C++23）
    //    需要编译器 + 标准库同时支持，见下面的可用性说明
#if defined(__STDCPP_FLOAT16_T__) || defined(__cpp_lib_extended_float)
    std::float16_t  half   = 0.5f;      // 半精度
    std::float32_t  single = 3.14f;     // 单精度
    std::float64_t  dbl    = 3.14159;   // 双精度
    std::bfloat16_t brain  = 6.28f;     // bfloat16
    std::printf("sizeof: %zu %zu %zu %zu\n",
                sizeof half, sizeof single, sizeof dbl, sizeof brain);
#else
    std::printf("这个标准库还没有 <stdfloat>，下面改用编译器内置的扩展浮点类型\n");
#endif

    // ② 编译器内置的扩展浮点类型：不走 <stdfloat>，Apple 芯片上可用
    _Float16 h = 0.5f;
    std::printf("_Float16 = %f，sizeof = %zu 字节\n", (double)h, sizeof h);
}

1
2
3

$ clang++ -std=c++23 extfloat.cpp && ./a.out
这个标准库还没有 <stdfloat>，下面改用编译器内置的扩展浮点类型
_Float16 = 0.500000，sizeof = 2 字节

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

┌─────────────────────────────────────────────────────────────┐
│                    32-bit Float (float)                      │
├─────────────┬───────────────────────────────────────────────┤
│  Sign (1)   │  Exponent (8)     │  Mantissa (23)            │
└─────────────┴───────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│               16-bit Brain Float (bfloat16)                 │
├─────────────┬───────────────────────────────────────────────┤
│  Sign (1)   │  Exponent (8)     │  Mantissa (7)             │
└─────────────┴───────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│               16-bit Float (float16_t)                      │
├─────────────┬───────────────────────────────────────────────┤
│  Sign (1)   │  Exponent (5)     │  Mantissa (10)            │
└─────────────┴───────────────────────────────────────────────┘

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

#include <iostream>
#include <string>
#include <string_view>

int main() {
    // 标准库没有 trim，这里用 string_view + find_first_not_of 手写一个
    
    std::string s = "   Hello, C++23!   ";
    
    // 注意：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

Original: '   Hello, C++23!   '
Trimmed: 'Hello, C++23!'

 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

#include <iostream>

struct Base {
    int x, y;
    Base(int x, int y) : x(x), y(y) {
        std::cout << "Base constructed with (" << x << ", " << y << ")" << std::endl;
    }
};

struct Derived : Base {
    using Base::Base;  // 继承构造函数
};

int main() {
    // C++23: 继承构造函数的CTAD
    
    // 以前需要这样写：
    Derived d1(1, 2);  // 显式指定参数类型
    
    // C++23可以通过CTAD直接推导
    Derived d2 = Derived(1, 2);  // 自动推导
    
    std::cout << "d2.x = " << d2.x << ", d2.y = " << d2.y << std::endl;  // 输出: 1, 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45

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

template<typename T>
struct Wrapper {
    T value;
    
    template<typename U>
    Wrapper(U&& v) : value(std::forward<U>(v)) {}
};

struct Base1 {
    int a;
    Base1(int a = 0) : a(a) {}      // 给默认值，否则被继承到 Derived 的构造函数会被隐式删除
};

struct Base2 {
    double b;
    Base2(double b = 0.0) : b(b) {}  // 同上
};

// 多继承情况
struct Derived : Base1, Base2 {
    using Base1::Base1;
    using Base2::Base2;
};

int main() {
    // C++23: 继承构造函数CTAD
    
    // 单继承
    Derived d1(42);  // 继承自Base1的构造函数
    std::cout << "d1.a = " << d1.a << std::endl;  // 输出: 42
    
    // Wrapper和继承构造函数结合
    struct IntWrapper : Wrapper<int> {
        using Wrapper<int>::Wrapper;
    };
    
    IntWrapper w(100);
    std::cout << "w.value = " << w.value << 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

#include <iostream>

struct Base {
    int x;
    Base(int x) : x(x) {}
};

struct Derived : Base {
    using Base::Base;
    
    // 如果派生类定义了同名成员，可能会有问题
    // int x;  // 如果取消注释，会有歧义
};

int main() {
    // C++23中，继承构造函数的CTAD
    Derived d(10);
    std::cout << "d.x = " << d.x << std::endl;  // 输出: 10
    
    return 0;
}