Bingliaolong 2024-06-30 17:12 Aet | 隐藏边栏 | 抢沙发 | 3 0

文章评分 3 次，平均分 5.0 ：

语言特性

概念`Concepts`

概述

概念用于约束模板参数，提供了一种简洁的方式来指定模板参数的要求
约束模板参数，增强代码可读性和错误提示

示例

示例1

#include <concepts>

#include <iostream>

template<typename T>

concept Incrementable = requires(T x) {

++x;

x++;

};

template<Incrementable T>

void increment(T& x) {

++x;

}

int main() {

int i = 0;

increment(i);

std::cout << i << std::endl;

return 0;

}

示例2

#include <concepts>

template<typename T>

concept Sortable = requires(T a, T b) {

{ a < b } -> std::convertible_to<bool>;

};

template<Sortable T>

void sort(T arr[], int size) { /* 排序实现 */ }

// 使用

int main() {

int arr[] = {3, 1, 4};

sort(arr, 3); // 合法，int 满足 Sortable

}

范围库（`Ranges`）

概述

提供声明式数据操作，支持惰性求值和链式调用

#include <ranges>

#include <vector>

#include <iostream>

int main() {

std::vector<int> vec = {1, 2, 3, 4, 5};

auto even = vec | std::views::filter([](int n) { return n % 2 == 0; });

for (int n : even) {

std::cout << n << " ";

}

return 0;

}

示例

过滤偶数并平方

#include <ranges>

#include <vector>

#include <iostream>

int main() {

std::vector<int> nums{1, 2, 3, 4, 5};

auto result = nums | std::views::filter([](int x) { return x % 2 == 0; })

| std::views::transform([](int x) { return x * x; });

for (int v : result) std::cout << v << " "; // 输出 4 16

}

协程（Coroutines）

概述

C++20 引入的一种新特性，提供了一种可以暂停和恢复的函数形式，使得编写异步代码更加简单和直观
1. 协程通过 co_await、co_yield 和 co_return 等关键字来实现，能够在异步编程、生成器、任务调度等场景中发挥作用

概念

协程函数：
1. 包含 co_await、co_yield 或 co_return 关键字的函数被称为协程函数
2. 协程函数的返回类型必须是支持协程的类型，如 std::coroutine_handle 或用户自定义类型
协程句柄：
1. std::coroutine_handle 是一个可以控制协程执行的句柄，允许暂停、恢复和销毁协程
协程承诺类型（Promise Type）：
1. 每个协程函数都有一个关联的承诺类型（promise type），它负责管理协程的状态、返回值和异常处理

协程生命周期

初始化
1. 调用协程函数时，生成一个协程状态对象，并调用 initial_suspend 以决定协程是否立即挂起
执行
1. 协程从挂起点恢复执行，直到遇到 co_await、co_yield 或 co_return
挂起
1. co_await 和 co_yield 关键字会导致协程挂起，返回控制权给调用者
恢复
1. 外部可以通过协程句柄恢复协程的执行
完成
1. 协程执行到 co_return 或结尾时，调用 final_suspend，释放协程资源

示例1

Task 构造函数接收一个 std::coroutine_handle<promise_type>，用于管理协程的生命周期
Task 析构函数在协程句柄有效时销毁协程，以释放资源
hello 协程函数：
1. 在 hello 中，co_await std::suspend_always{} 使协程在输出 Hello, 后挂起，需要显式恢复
恢复协程：
1. 在 main 函数中，通过 h.coro.resume() 恢复协程的执行，继续输出 World!\n

#include <coroutine>

#include <iostream>

struct Task {

struct promise_type {

Task get_return_object() {

return Task{std::coroutine_handle<promise_type>::from_promise(*this)};

}

std::suspend_always initial_suspend() { return {}; }

std::suspend_always final_suspend() noexcept { return {}; }

void return_void() {}

void unhandled_exception() {}

};

std::coroutine_handle<promise_type> coro;

Task(std::coroutine_handle<promise_type> h) : coro(h) {}

~Task() { if (coro) coro.destroy(); }

};

Task hello() {

std::cout << "Hello, ";

co_await std::suspend_always{};

std::cout << "World!\n";

}

int main() {

auto h = hello();

h.coro.resume(); // 恢复协程，继续执行

return 0;

}

promise_type

promise_type 是协程的核心部分，用于管理协程的状态
每个协程类型都必须定义一个嵌套的 promise_type 结构，该结构负责处理协程的创建、挂起、恢复和销毁
1. 虽然具体的实现可以根据需要进行定制，但某些函数是固定的，因为它们是协程框架调用的接口
get_return_object：
1. 这个函数用于返回协程的返回对象。它在协程开始时被调用

Task get_return_object() {

return Task{std::coroutine_handle<promise_type>::from_promise(*this)};

}

initial_suspend：
1. 这个函数返回一个等待操作，决定协程在启动时是否挂起

std::suspend_always initial_suspend() {

return {};

}

final_suspend：
1. 这个函数返回一个等待操作，决定协程在结束时是否挂起

std::suspend_always final_suspend() noexcept {

return {};

}

return_void / return_value：
1. 这两个函数用于处理协程的返回值
2. return_void 用于没有返回值的协程，return_value 用于有返回值的协程

void return_void() {}

void return_value(int value) {

this->value = value;

}

unhandled_exception：
1. 这个函数用于处理协程中的未处理异常

void unhandled_exception() {

std::terminate();

}

示例2

生成斐波那契数列：

#include <coroutine>

#include <iostream>

Generator<int> fibonacci() {

int a = 0, b = 1;

while (true) {

co_yield a;

std::tie(a, b) = std::make_pair(b, a + b);

}

int main() {

auto gen = fibonacci();

for (int i = 0; i < 10; ++i) {

std::cout << gen.next() << " "; // 输出 0 1 1 2 3 5 8 13 21 34

}

模块

概述

模块是 C++20 引入的一种新机制，用于替代传统的头文件，提供更好的编译性能和模块化支持
1. 不需要传统的头文件
总的来说，就是替代头文件，提高编译速度，增强封装性

// hello.cpp

module;

#include <iostream>

export module hello;

export void say_hello() {

std::cout << "Hello, World!\n";

}

// main.cpp

import hello;

int main() {

say_hello();

return 0;

}

示例

示例1

// math.ixx

export module math;

export int add(int a, int b) { return a + b; }

// main.cpp

import math;

int main() {

return add(2, 3); // 返回 5

}

三路比较运算符

C++20 引入了三方比较运算符，用于统一和简化比较操作
在 C++20 中，三方比较运算符可以自动生成

#include <iostream>

#include <compare>

struct Point {

int x, y;

auto operator<=>(const Point&) const = default;

};

int main() {

Point p1{1, 2}, p2{1, 3};

if (p1 < p2) std::cout << "p1 < p2\n";

if (p1 == p2) std::cout << "p1 == p2\n";

return 0;

}

auto operator<=>(const Point&) const = default;
1. 告诉编译器为 Point 结构体自动生成三方比较运算符
2. 意味着编译器会自动生成对 Point 结构体中所有成员变量
  （在这个例子中是 x 和 y）的逐个比较操作
当编译器自动生成三方比较运算符时，它会按照成员声明的顺序依次比较每个成员，并返回第一个非零的比较结果
1. 如果所有成员都相等，则比较结果为零
生成的比较运算符:
1. operator<=>：用于 <=> 比较操作，返回 std::strong_ordering
2. operator==：用于相等比较操作
C++20 提供了几种不同的三方比较类型：
1. std::strong_ordering：强序关系，适用于完全排序的类型（例如 int、double）
2. std::weak_ordering：弱序关系，适用于可以相等但不完全排序的类型
3. std::partial_ordering：部分序关系，适用于可能不完全比较的类型（例如 NaN）
假如上面的Point结构体里面有个string呢
1. std::string 类型本身已经支持三方比较运算符，因此编译器可以正确地生成比较运算符

#include <compare>

struct Point {

int x, y;

auto operator<=>(const Point&) const = default;

};

int main() {

Point a{1, 2}, b{3, 4};

bool lt = a < b; // 合法，自动使用 <=> 比较

bool eq = a == b; // 合法，自动生成

}

`consteval` 和 `constinit`

概述

C++20 引入了 consteval 和 constinit 两个关键字，分别用于增强编译期计算和初始化的控制

`consteval`（立即函数）

核心作用
1. 声明函数为必须编译期求值的立即函数（Immediate Function）
2. 函数只能在编译期调用，禁止运行时调用
3. 用于强制生成编译期常量，替代 constexpr 函数在运行时可能被误用的场景
场景
1. 必须生成编译期常量的计算（如查找表、加密密钥生成）
2. 替代 constexpr 以禁止运行时调用
示例

// consteval 函数：只能在编译期调用

consteval int square(int x) {

return x * x;

}

int main() {

constexpr int a = square(5); // 合法：编译期计算

int b = square(5); // 合法：编译期计算后赋值给变量

// int c = square(rand()); // 错误！运行时参数无法调用 consteval 函数

}

`consteval`与 `constexpr` 的区别


特性	`constexpr` 函数	`consteval` 函数
调用时机	允许编译期和运行时调用	必须编译期调用
返回值用途	可赋值给 `constexpr` 或普通变量	只能赋值给编译期已知的变量

`constinit`（强制编译期初始化）

核心作用
1. 确保变量在编译期完成初始化，避免静态初始化顺序问题
2. 仅适用于静态存储期变量（全局、static、thread_local）
3. 变量可以是非常量，但必须用常量表达式初始化
4. 替代 constexpr 定义需要运行时修改的全局变量
场景
1. 解决跨编译单元的全局变量初始化顺序问题
示例1

// 编译期初始化函数

constexpr int initValue() {

return 42;

}

// 合法：编译期初始化

constinit int global = initValue();

void demo() {

// 合法：static 变量使用 constinit

static constinit int counter = 0;

counter++;

}

// constinit int error = rand(); // 错误！rand() 不是常量表达式

`constinit`与 `constexpr` 变量的区别


特性	`constexpr` 变量	`constinit` 变量
常量性	必须是常量	可以是变量（允许后续修改）
初始化要求	必须用常量表达式初始化	必须用常量表达式初始化
适用存储类型	不限	仅限静态存储期变量

联合示例

// 编译期计算初始化值

consteval int computeHash(int seed) {

return seed * 2654435761; // 示例哈希计算

}

// 强制全局变量在编译期初始化

constinit int globalHash = computeHash(42);

int main() {

globalHash = computeHash(100); // 合法：constinit 变量可修改

// constinit int local = 10; // 错误！局部变量不能用 constinit

}

consteval int square(int n) {

return n * n;

}

constinit int x = 42; // 确保在编译时初始化

int main() {

constexpr int val = square(5); // 编译时求值

return 0;

}

标准库新增组件

`std::format`

概述

C++20 引入了 std::format，这是一个强大且灵活的字符串格式化工具，类似于 Python 的 str.format
它提供了一种类型安全、可读性好且高效的方式来格式化字符串

用法

用于格式化字符串，并返回一个格式化后的 std::string
使用大括号 {} 作为占位符，并支持多种格式化选项

#include <iostream>

#include <format>

int main() {

int x = 42;

double y = 3.14159;

std::string s = "world";

std::string result = std::format("Hello, {}! The answer is {} and pi is {:.2f}", s, x, y);

std::cout << result << std::endl;

return 0;

}

#include <format>

#include <iostream>

int main() {

std::string s = std::format("Hello, {}!", "world");

std::cout << s << std::endl; // 输出 "Hello, world!"

return 0;

}

数字格式化

整数

int n = 42;

std::string s1 = std::format("Decimal: {}", n); // "Decimal: 42"

std::string s2 = std::format("Hex: {:x}", n); // "Hex: 2a"

std::string s3 = std::format("Octal: {:o}", n); // "Octal: 52"

std::string s4 = std::format("Binary: {:b}", n); // "Binary: 101010"

浮点数

double pi = 3.14159;

std::string s1 = std::format("Default: {}", pi); // "Default: 3.14159"

std::string s2 = std::format("Fixed: {:.2f}", pi); // "Fixed: 3.14"

std::string s3 = std::format("Scientific: {:.2e}", pi); // "Scientific: 3.14e+00"

字符串对齐和填充

std::string str = "Hello";

std::string s1 = std::format("|{:10}|", str); // "|Hello |" 右对齐，默认填充空格

std::string s2 = std::format("|{:<10}|", str); // "|Hello |" 左对齐

std::string s3 = std::format("|{:^10}|", str); // "| Hello |" 居中对齐

std::string s4 = std::format("|{:-^10}|", str); // "|--Hello---|" 居中对齐，填充 -

命名参数

目前，std::format 不直接支持命名参数，但你可以使用结构绑定或 std::tuple 来实现类似功能

#include <tuple>

#include <format>

#include <iostream>

int main() {

auto params = std::make_tuple(42, 3.14159, "world");

std::string result = std::vformat("Hello, {}! The answer is {} and pi is {:.2f}", std::make_format_args(std::get<2>(params), std::get<0>(params), std::get<1>(params)));

std::cout << result << std::endl;

return 0;

}

格式化类成员

#include <format>

#include <string>

#include <iostream>

class Point {

public:

int x, y;

Point(int x, int y) : x(x), y(y) {}

std::string to_string() const {

return std::format("Point({}, {})", x, y);

}

};

int main() {

Point p(10, 20);

std::cout << p.to_string() << std::endl; // 输出 Point(10, 20)

return 0;

}

自定义格式化

可以为自定义类型实现格式化支持，通过定义特化的 std::formatter 模板

#include <format>

#include <string>

#include <iostream>

class Point {

public:

int x, y;

Point(int x, int y) : x(x), y(y) {}

};

// 自定义格式化

template <>

struct std::formatter<Point> {

constexpr auto parse(format_parse_context& ctx) {

return ctx.begin();

}

auto format(const Point& p, format_context& ctx) {

return format_to(ctx.out(), "({}, {})", p.x, p.y);

}

};

int main() {

Point p(10, 20);

std::cout << std::format("Point: {}", p) << std::endl; // 输出 Point: (10, 20)

return 0;

}

`std::span`

std::span 提供了一种视图类型，用于表示连续的内存块
1. 非拥有视图，安全访问连续内存序列（如数组、向量）

#include <span>

#include <iostream>

#include <vector>

void print(std::span<int> sp) {

for (int i : sp) {

std::cout << i << " ";

}

std::cout << std::endl;

}

int main() {

std::vector<int> vec = {1, 2, 3, 4};

print(vec); // 直接传递 vector

int arr[] = {5, 6, 7, 8};

print(arr); // 直接传递数组

return 0;

}

日历和时区库（`chrono`扩展）

概述

处理日期和时间，支持时区转换

示例

#include <chrono>

#include <iostream>

using namespace std::chrono;

int main() {

auto now = system_clock::now();

auto local = zoned_time{current_zone(), now};

std::cout << local << '\n'; // 输出当前本地时间（如 "2023-08-20 15:30:00 CST"）

}

`std::jthread` 和 `std::stop_token`

概述

C++20 引入了 std::jthread 和 std::stop_token，用于更好的线程管理和停止操作

#include <thread>

#include <iostream>

void worker(std::stop_token stopToken) {

while (!stopToken.stop_requested()) {

std::this_thread::sleep_for(std::chrono::milliseconds(100));

std::cout << "Working...\n";

}

int main() {

std::jthread t(worker);

std::this_thread::sleep_for(std::chrono::seconds(1));

t.request_stop();

return 0;

}

`std::jthread`

C++20 引入的新型线程类，它的名字中的 "j" 代表 "joining"
与传统的 std::thread 不同，std::jthread 在析构时会自动等待（join）线程的结束，从而避免了某些常见的资源泄露和线程管理问题
特点：
1. 自动 join：std::jthread 在对象析构时自动调用 join()
2. 支持停止请求：结合 std::stop_token 使用，可以优雅地请求线程停止

#include <iostream>

#include <thread>

#include <chrono>

#include <stop_token>

void work(std::stop_token st) {

while (!st.stop_requested()) {

std::cout << "Working..." << std::endl;

std::this_thread::sleep_for(std::chrono::milliseconds(500));

}

std::cout << "Stopped!" << std::endl;

}

int main() {

std::jthread t(work); // 创建并启动线程

std::this_thread::sleep_for(std::chrono::seconds(2));

t.request_stop(); // 请求停止线程

// t 会自动 join，在此之前确保它完成

return 0;

}

std::stop_token

线程函数通过它检查是否有停止请求
1. 是一种新的机制，用于请求线程停止
它和 std::stop_source、std::stop_callback 一起使用，提供了一种更灵活的线程停止管理方式

std::stop_source

用于发出停止请求

std::stop_callback

用于在停止请求发出时执行回调
下面的示例中，在st上面注册了一个回调函数[](){...}
1. 当t.request_stop();这一行运行后，会先调用注册的这个回调函数，然后再走道while循环这里的逻辑

#include <iostream>

#include <thread>

#include <chrono>

#include <stop_token>

void work(std::stop_token st) {

auto callback = std::stop_callback(st, []() {

std::cout << "Stop requested, executing callback..." << std::endl;

});

while (!st.stop_requested()) {

std::cout << "Working..." << std::endl;

std::this_thread::sleep_for(std::chrono::milliseconds(500));

}

std::cout << "Stopped!" << std::endl;

}

int main() {

std::jthread t(work); // 创建并启动线程

std::this_thread::sleep_for(std::chrono::seconds(2));

t.request_stop(); // 请求停止线程

// t 会自动 join，在此之前确保它完成

return 0;

}

其他重要改进

`constexpr` 改进

编译时计算

C++20 对 constexpr 进行了改进，允许更多的复杂表达式在编译时计算

#include <array>

constexpr int factorial(int n) {

if (n <= 1) return 1;

else return n * factorial(n - 1);

}

int main() {

constexpr int val = factorial(5);

std::array<int, factorial(3)> arr; // 可以在编译时计算

return 0;

}

编译期使用动态内存分配和虚函数

允许在编译期使用动态内存分配和虚函数

constexpr int compileTimeSum() {

int* arr = new int[3]{1, 2, 3};

int sum = arr[0] + arr[1] + arr[2];

delete[] arr;

return sum;

}

static_assert(compileTimeSum() == 6); // 编译期计算

`[[no_unique_address]]`

优化空类成员的内存占用

struct Empty {}; // 空类

struct Optimized {

int x;

[[no_unique_address]] Empty e; // 不占用额外内存

};

static_assert(sizeof(Optimized) == sizeof(int)); // 成立

位操作库（`<bit>`）

概述

C++20 引入了 <bit> 头文件，提供了一系列高效且可移植的位操作函数，涵盖位转换、循环移位、位计数和字节序处理等功能

#include <bit>

#include <iostream>

int main() {

unsigned int x = 0b1010;

std::cout << std::popcount(x); // 输出 2（二进制中 1 的数量）

}

`std::bit_cast`

C++20 引入的一个标准库函数，用于进行类型安全的位级别转换（bitwise cast）
1. 安全地将对象的位模式转换为另一种类型，无需类型双关（Type Punning）
2. 它可以将一个对象的比特表示（bit representation）重新解释为另一种类型，而不改变对象的实际内存内容
3. 这在需要进行底层操作或优化时非常有用，同时提供了类型安全性
要求
1. 源类型和目标类型大小相同且均为可平凡复制（Trivially Copyable）
定义

1 2	template <class To, class From> To bit_cast(const From& from) noexcept;

关键
1. To 和 From 必须是同样大小的标准布局类型（standard-layout types）
2. To 必须是可平凡复制构造的（trivially copyable）
3. std::bit_cast 是一个常量表达式函数，这意味着它可以在编译时计算结果
示例

#include <bit>

#include <iostream>

int main() {

float f = 3.14f;

int i = std::bit_cast<int>(f);

std::cout << i << std::endl;

return 0;

}

#include <bit>

#include <cstdint>

#include <iostream>

int main() {

float f = 3.14f;

// 将 float 的位模式转换为 uint32_t

auto u = std::bit_cast<uint32_t>(f);

std::cout << "Float bits: 0x" << std::hex << u << '\n';

// 输出类似 "Float bits: 0x4048f5c3"

}

循环移位函数

std::rotl(x, s)：循环左移 s 位
std::rotr(x, s)：循环右移 s 位
若 s 为负数，自动取模转换（如 rotl(x, -1) 等价于 rotl(x, sizeof(x)*8 - 1)）

#include <bit>

#include <cstdint>

#include <iostream>

int main() {

uint32_t x = 0x12345678;

auto y = std::rotl(x, 4); // 循环左移 4 位

std::cout << "rotl(0x12345678, 4): 0x" << std::hex << y << '\n';

// 输出 "rotl(0x12345678, 4): 0x23456781"

}

位计数函数

std::countl_zero(x)：从最高位开始连续 0 的个数（前导零）
std::countr_zero(x)：从最低位开始连续 0 的个数（末尾零）
std::countl_one(x)：从最高位开始连续 1 的个数
std::countr_one(x)：从最低位开始连续 1 的个数

#include <bit>

#include <cstdint>

#include <iostream>

int main() {

uint32_t x = 0x0000FFFF; // 二进制: 0000 0000 0000 0000 1111 1111 1111 1111

int leading_zeros = std::countl_zero(x);

int trailing_ones = std::countr_one(x);

std::cout << "前导零: " << leading_zeros << '\n'; // 输出 16

std::cout << "末尾连续1的个数: " << trailing_ones << '\n'; // 输出 16

}

`std::popcount`（统计置位数）

计算整数二进制表示中 1 的个数

#include <bit>

#include <cstdint>

#include <iostream>

int main() {

uint16_t x = 0x5555; // 二进制: 0101 0101 0101 0101

int ones = std::popcount(x);

std::cout << "1的个数: " << ones << '\n'; // 输出 8

}

字节序处理

枚举：std::endian
1. std::endian::little：小端序
2. std::endian::big：大端序
3. std::endian::native：当前系统字节序

#include <bit>

#include <iostream>

int main() {

if constexpr (std::endian::native == std::endian::little) {

std::cout << "当前系统为小端序\n";

} else if (std::endian::native == std::endian::big) {

std::cout << "当前系统为大端序\n";

}

统一的调用约定（Uniform Call Syntax）

概述

允许成员函数和自由函数使用相同的语法调用
C++20引入了 std::size 和其他类似的标准库函数，使得可以对标准容器和数组等数据结构统一地调用这些函数，而不必关心它们是成员函数还是全局函数

#include <iostream>

#include <vector>

void print_size(const std::vector<int>& vec) {

std::cout << std::size(vec) << std::endl;

}

int main() {

std::vector<int> vec = {1, 2, 3, 4};

print_size(vec); // 支持统一调用约定

return 0;

}

函数

std::size：获取容器或数组的大小
std::data：获取容器或数组的底层数据指针
std::empty：检查容器或数组是否为空

#include <iostream>

#include <vector>

#include <array>

void print_size(const auto& container) {

std::cout << std::size(container) << std::endl;

}

int main() {

std::vector<int> vec = {1, 2, 3, 4};

std::array<int, 4> arr = {5, 6, 7, 8};

int c_arr[4] = {9, 10, 11, 12};

print_size(vec); // 输出 4

print_size(arr); // 输出 4

print_size(c_arr); // 输出 4

return 0;

}

概念Concepts
概述
示例
范围库（Ranges）
概述
示例
协程（Coroutines）
概述
概念
协程生命周期
示例1
promise_type
示例2
模块
概述
示例
三路比较运算符
consteval 和 constinit
概述
consteval（立即函数）
consteval与 constexpr 的区别
constinit（强制编译期初始化）
constinit与 constexpr 变量的区别
联合示例
std::format
概述
用法
数字格式化
命名参数
格式化类成员
自定义格式化
std::span
日历和时区库（chrono扩展）
概述
示例
std::jthread 和 std::stop_token
概述
std::jthread
std::stop_token
std::stop_source
std::stop_callback
constexpr 改进
编译时计算
编译期使用动态内存分配和虚函数
[[no_unique_address]]
位操作库（<bit>）
概述
std::bit_cast
循环移位函数
位计数函数
std::popcount（统计置位数）
字节序处理
统一的调用约定（Uniform Call Syntax）
概述
函数

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2025-03-21

Everything will be better.

C++20_第一篇

语言特性

概念Concepts

概述

示例

范围库（Ranges）

概述

示例

协程（Coroutines）

概述

概念

协程生命周期

示例1

promise_type

示例2

模块

概述

示例

三路比较运算符

consteval 和 constinit

概述

consteval（立即函数）

consteval与 constexpr 的区别

constinit（强制编译期初始化）

constinit与 constexpr 变量的区别

联合示例

标准库新增组件

std::format

概述

用法

数字格式化

命名参数

格式化类成员

自定义格式化

std::span

日历和时区库（chrono扩展）

概述

示例

std::jthread 和 std::stop_token

概述

std::jthread

std::stop_token

std::stop_source

std::stop_callback

其他重要改进

constexpr 改进

编译时计算

编译期使用动态内存分配和虚函数

[[no_unique_address]]

位操作库（<bit>）

概述

std::bit_cast

循环移位函数

位计数函数

std::popcount（统计置位数）

字节序处理

统一的调用约定（Uniform Call Syntax）

概述

函数

你可能也喜欢

热评文章

发表评论

标签云集

概念`Concepts`

范围库（`Ranges`）

`consteval` 和 `constinit`

`consteval`（立即函数）

`consteval`与 `constexpr` 的区别

`constinit`（强制编译期初始化）

`constinit`与 `constexpr` 变量的区别

`std::format`

`std::span`

日历和时区库（`chrono`扩展）

`std::jthread` 和 `std::stop_token`

`std::jthread`

`constexpr` 改进

`[[no_unique_address]]`

位操作库（`<bit>`）

`std::bit_cast`

`std::popcount`（统计置位数）