C++20新特性
C++20新特性
新增关键字(keywords)
concept
requires
constinit
consteval
co_await
co_return
co_yield
char8_t
模块(Modules)
优点:
1）没有头文件；
2）声明实现仍然可分离, 但非必要；
3）可以显式指定导出哪些类或函数；
4）不需要头文件重复引入宏 (include guards)；
5）模块之间名称可以相同，并且不会冲突；
6）模块只处理一次, 编译更快 (头文件每次引入都需要处理)；
7）预处理宏只在模块内有效；
8）模块的引入与引入顺序无关。
例子:
Module code (test.ixx)
// export module xxx.yyy.zzz
export module cpp20.test;
// Failed to import lib
//import std.core;
//import std.filesystem;
/////////////////////////////////////////////
// common export
export auto GetCommonString() {
return "Welcome to learn C++20!";
}
auto GetSpecificString() {
return "Welcome to learn C++20!";
}
// error.Because std::core has been not imported
//export std::string GetString() {
// return "GetString.";
//}
/////////////////////////////////////////////
/////////////////////////////////////////////
// entirety export
export namespace test {
auto GetTestString() {
return "Test Test Test!!!";
}
template <typename T>
T Sum(T t)
{
return t;
}
template <typename T, typename ...Args>
T Sum(T one, Args ...args)
{
return one + Sum<T>(args...);
}
enum class ValueType
{
kBool=0,
kChar,
kInt,
kFloat,
kDouble,
};
template <typename T>
T GetDataType(ValueType type) {
switch (type)
{
using enum ValueType;
case kBool:
return true;
case kChar:
return 'A';
case kInt:
return 5;
case kFloat:
return 12.257902012398877;
case kDouble:
return 12.257902012398877;
}
return true;
}
}// namespace test
/////////////////////////////////////////////
/////////////////////////////////////////////
// struct export
export namespace StructTest {
struct Grade {
int val = 0;
int level = 5;
};
void AddVal(Grade& g, int num) {
g.val += num;
g.level += num;
}
}// namespace StructTest
/////////////////////////////////////////////
Calling code (main.cpp)
import cpp20.test;
int main(int argc, char* argv[]) {
auto ret1 = GetCommonString();
//auto ret2 = GetSpecificString(); // error
//auto ret2 = GetString(); // error
using namespace test;
auto ret3 = GetTestString();
auto ret4 = Sum<int>(3, 4);
auto ret5 = Sum<double>(3.14, 4.62, 9.14);
auto ret6 = GetDataType<bool>(ValueType::kBool);
auto ret7 = GetDataType<int>(ValueType::kInt);
auto ret8 = GetDataType<char>(ValueType::kChar);
StructTest::Grade grade;
StructTest::AddVal(grade, 10);
std::cout << grade.val << " | " << grade.level << std::endl;
return 0;
}
总结
1）模块的命名可选择格式为：xxx.yyy.zzz
2）在MSVC编译器中，模块文件是.ixx，而不是.cpp。（.ixx文件后缀是MSVC编译器中默认的模块接口，C++ 模块接口单元）
3）普通函数的导出必须添加"export"；否则，外部无法调用。也可以选择导出命名空间块。详情可参见上述的例子。
4）标准库core和文件系统filesystem，提供的函数无法被识别。可能是本人导入module配置操作有误吧！
5）模块当前支持基本数据类型，比如bool、int、float、char等。也支持结构与类的使用。
6）模块的定义没有头文件、不会重复编译输出、导入模块没有次序区别，因此建议模块的编写添加相应的命名空间，降低相同符号的可能性。
详情例子请参见：
C++20 模块
VS2019中关于module的配置
泛化之美--C++11可变模版参数的妙用
协程(Coroutines)
进程：操作系统资源分配的基本单元。调度涉及到用户空间和内核空间的切换，资源消耗较大。
线程：操作系统运行的基本单元。在同一个进程资源的框架下，实现抢占式多任务，相对进程，降低了执行单元切换的资源消耗。
协程：和线程非常类似。但是转变一个思路实现协作式多任务，由用户来实现协作式调度，即主动交出控制权(或称为用户态的线程)。
到底什么是协程？
简单来说，协程就是一种特殊的函数，它可以在函数执行到某个地方的时候暂停执行，返回给调用者或恢复者（可以有一个返回值），并允许随后从暂停的地方恢复继续执行。
请注意，这个暂停执行不是指将函数所在的线程暂停执行，而是单纯的暂停执行函数本身。
说白了，用处就是将“异步”风格的编程“同步”化。
C++20 协程的特点
1）不需要内部栈分配，仅需要一个调用栈的顶层桢。
2）协程运行过程中，需要使用关键词来控制运行过程（比如co_return）。
3）协程可能分配不同线程，触发资源竞争。
4）没有调度器，但是需要标准和编译器的支持。
协程的特点在于是一个线程执行，那和多线程相比，协程有何优势？
优点：
1）极高的执行效率：因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销。和多线程比，线程数量越多，协程的性能优势就越明显。
2）不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
缺点：
1）无法利用多核资源：协程的本质是个单线程，它不能同时将单个CPU 的多个核用上，协程需要和进程配合才能运行在多CPU上。当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
2）进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序。
协程中的关键字
co_wait: 挂起协程, 等待其它计算完成。
co_return: 从协程返回 (协程 return 禁止使用)。
co_yield: 返回一个结果并且挂起当前的协程, 下一次调用继续协程的运行。
注意：上述的协程关键字只能在协程中使用。这也就意味着，在main函数中直接调用co_await xxxx(); 是不行的。
如何定义与使用协程？
先了解几个基本的概念：
1）一个线程只能有一个协程；
2）协程函数需要返回值是Promise；
3）协程的所有关键字必须在协程函数中使用；
4）在协程函数中可以按照同步的方式去调用异步函数，只需要将异步函数包装在Awaitable类中，使用co_wait关键字调用即可。
理解了以上概念后，就可以按照特定的规则创建和使用协程：
1）在一个线程中同一个时间只调用一个协程函数，即只有一个协程函数执行完毕了，再去调用另一个协程函数；
2）使用Awatiable类包装所有的异步函数，一个异步函数处理一请求中的一部分工作（比如执行一次SQL查询，或者执行一次http请求等）；
3）在对应的协程函数中按照需要，通过增加co_wait关键字同步的调用这些异步函数。注意一个异步函数（包装好的Awaiable类）可以在多个协程函数中调用，协程函数可能在多个线程中被调用（虽然一个线程同一时间只调用一个协程函数），所以最好保证Awaiable类是线程安全的，避免出现需要加锁的情况；
4）在线程中通过调用不同的协程函数响应不同的请求。
协程一般需要定义三个东西：协程体（coroutine），协程承诺特征类型（Traits），await对象（await）。
C++20 协程模板：(仅供参考，非官方标准)
#include <thread>
#include <coroutine>
#include <functional>
#include <windows.h>
// 给协程体使用的承诺特征类型
struct CoroutineTraits { // 名称自定义 |Test|
struct promise_type { //名称必须为 |promise_type|
// 必须实现此接口。(协程体被创建时被调用)
auto get_return_object() {
return CoroutineTraits{};
};
// 必须实现此接口, 返回值必须为awaitable类型。(get_return_object之后被调用)
auto initial_suspend() {
return std::suspend_never{}; // never表示继续运行
//return std::suspend_always{}; // always表示协程挂起
}
// 必须实现此接口, 返回值必须为awaitable类型。(return_void之后被调用)
// MSVC需要声明为noexcept，否则报错
auto final_suspend() noexcept {
return std::suspend_never{};
}
// 必须实现此接口, 用于处理协程函数内部抛出错误
void unhandled_exception() {
std::terminate();
}
// 如果协程函数内部无关键字co_return则必须实现此接口。(协程体执行完之后被调用)
void return_void() {}
// 注意：|return_void|和|return_value| 是互斥的。
// 如果协程函数内部有关键字co_return则必须实现此接口。(协程体执行完之后被调用)
//void return_value() {}
// 如果协程函数内部有关键字co_yield则必须实现此接口, 返回值必须为awaitable类型
auto yield_value(int value) {
// _valu=value; // 可对|value|做一些保存或其他处理
return std::suspend_always{};
}
};
};
// 协程使用的await对象
struct CoroutineAwaitObj { // 名称自定义 |CoroutineAwaitObj|
// await是否已经计算完成，如果返回true，则co_await将直接在当前线程返回
bool await_ready() const {
return false;
}
// await对象计算完成之后返回结果
std::string await_resume() const {
return _result;
}
// await对象真正调异步执行的地方，异步完成之后通过handle.resume()来是await返回
void await_suspend(const std::coroutine_handle<> handle) {
std::jthread([handle, this]() {
// 其他操作处理
_result = "Test";
// 恢复协程
handle.resume();
}).detach();
}
// 将返回值存在这里
std::string _result;
};
// 协程体
// |CoroutineTraits| 并不是返回值，而是协程的特征类型；不可以是void、string等返回类型
CoroutineTraits CoroutineFunc() {
std::cout << "Start CoroutineFunc" << std::endl;
auto ret = co_await CoroutineAwaitObj();
std::cout << "Return:" << ret << std::endl;
std::cout << "Finish CoroutineFunc" << std::endl;
}
int main(int argc, char* argv[]) {
CoroutineFunc();
Sleep(10*1000);
return 0;
}
协程的执行流程
解析：
1）先执行结构体promise_type() ，创建一个promise对象；
2）通过promise对象, 执行get_return_object(), 产生一个coroutine_name对象, 并记录handle；
3）执行initial_suspend(), 根据返回值的await_ready()返回值 判断是否立即执行协程函数, 当返回值中await_ready()返回值为ture则立即执行协程函数, 否则调用返回值的await_suspend挂起协程、跳出到主函数。
我们这里返回值是std::suspend_always，它的await_ready()始终返回false。
4）在主函数中调用协程函数CoroutineFunc（），同时将执行权传递给协程函数；
5）执行协程函数中操作，直到执行co_wait、co_return、co_yield；
6）执行awaitable类中的函数await_ready()，根据返回值判断是否将执行权传递给主函数。如果返回值的await_ready返回false，则调用await_suspend();若await_ready返回true，直接执行await_resume()，并返回到主函数(即await_suspend()不被执行)；
7）协程函数已经执行完语句，所以准备返回，这里没有co_return，所以调用的是return_void()函数。如果有co_return，则调用的是return_value()函数；
8）然后调用final_suspend，协程进行收尾动作。根据final_suspend的返回值的await_ready判断是否立即析构promise对象，返回true则立即析构，否则不立即析构、将执行权交给主函数；请注意：如果是立即析构promise对象，则后续主函数无法通过promise获得相应的值。
9）返回主函数执行其他操作，return 0。
协程的储存空间与生命周期
1）C++20 的设计是无栈协程, 所有的局部状态都储存在堆上。参见：有栈协程与无栈协程
2）储存协程的状态需要分配空间，分配 frame 的时候，首先会搜索 promise_type 是否有提供 operator new, 然后再搜索全局范围；
3）也会存在储存分配失败的情况。比如：如果写了 get_return_object_on_allocation_failure() 函数, 那就是失败后的办法, 代替 get_return_object() 来完成工作(可添加关键字 noexcept)；
4）协程结束以后的释放空间也会优先在 promise_type 里面搜索 operator delete, 其次再搜索全局范围.
5）协程的储存空间只有在运行完 final_suspend 之后才会析构, 或者人为显式地调用 handle.destroy(). 否则协程的存储空间就永远不会释放；如果在 final_suspend 那里停下了, 那么就得在包装函数里面手动调用 handle.destroy(), 否则就会出现内存泄漏。
6）如果已经运行完毕了 final_suspend, 或者已经被 handle.destroy() 给析构了, 那么协程的储存空间已经被释放了；如果再次对 handle 做任何的操作都会导致段错误。
协程用例请参考：
C++20 协程（coroutine）
C++20 Coroutines 协程
深入浅出c++协程
Ranges & Views
范围(ranges)：是“项目集合”或“可迭代事物”的抽象。最基本的定义只需要存在begin()和end()在范围内。Range 代表一串元素, 或者一串元素中的一段类似 begin/end 对。
视图(view)：其意义可以参考string_view，它的拷贝代价是很低的，需要拷贝的时候直接传值即可，不必传引用。
ranges通过增加了一种叫做view（视图）的概念，实现了Lazy Evaluation(惰性求值)，并且可以将各种view的关系转化用符号“|”串联起来。
范围适配器(range adaptor)：可以将一个range转换为一个view(也可以将一个view转换为另一个view)。范围适配器接受 viewable_range 为其第一参数并返回一个 view 。
常见的范围适配器：
| 适配器 | 描述 |
|---|---|
| views::filter | 由 range 中满足某个谓词的元素构成的 view |
| views::transform | 对序列的每个元素应用某个变换函数的 view |
| views::take | 由另一 view 的前 N 个元素组成的 view |
| views::join | 由拉平 range 的 view 所获得的序列构成的 view |
| views::elements | 选取仿 tuple 值组成的 view 和数值 N ，产生每个 tuple 的第 N 个元素的 view |
| views::drop | 由另一 view 跳过首 N 个元素组成的 view |
| views::all | 包含 range 的所有元素的 view |
| views::take_while | 由另一 view 的到首个谓词返回 false 为止的起始元素组成的 view |
| views::drop_while | 由另一 view 跳过元素的起始序列，直至首个谓词返回 false 的元素组成的 view |
| views::split | 用某个分隔符切割另一 view 所获得的子范围的 view |
| views::common | 转换 view 为 common_range |
| views::reverse | 以逆序迭代另一双向视图上的元素的 view |
| views::istream_view | 由在关联的输入流上相继应用 operator>> 获得的元素组成的 view |
| views::keys | 选取仿 pair 值组成的 view 并产生每个 pair 的第一元素的 view |
| views::values | 选取仿 pair 值组成的 view 并产生每个 pair 的第二元素的 view |
Ranges采用了C++ 20的最新特性Concepts，并且是惰性执行的。
下面是常见的range类型：
| 概念 | 描述 |
|---|---|
| std::ranges::input_range | 可以从头到尾重复至少一次(只可单次遍历的单向range) 比如 std::forward_list, std::list, std::deque, std::array |
| std::ranges::forward_range | 可以从头到尾重复多次(可以多次遍历的单向range) 比如 std::forward_list, std::list, std::deque, std::array |
| std::ranges::bidirectional_range | 迭代器还可以向后移动(双向range) 比如 std::list, std::deque, std::array |
| std::ranges::random_access_range | 可以恒定时间跳转到元素(支持随机访问的range) 比如 std::deque, std::array |
| std::ranges::contiguous_range | 元素总是连续存储在内存中(内容上连续的range) 比如 std::array |
范围适配器的简单实践
void Test() {
using namespace std::ranges;
std::string content{ "Hello! Welcome to learn new feature of C++ 20" };
for (auto word : content | views::split(' ')) {
std::cout << "-> ";
for (char iter : word |
views::transform([](char val) { return std::toupper(val); }))
std::cout << iter;
}
std::cout << std::endl;
// -> HELLO!-> WELCOME-> TO-> LEARN-> NEW-> FEATURE-> OF-> C++-> 20
std::vector<int> vet{ 0, 45, 15, 100, 0, 0, 11, 48, 0, 3, 99, 4, 0, 0, 0, 1485 , 418, 116, 0 };
std::vector<int> pat{ 0, 0 };
for (auto part : vet | views::split(pat)) {
std::cout << "-> ";
for (int iter : part)
std::cout << iter << ' ';
}
std::cout << std::endl;
// -> 0 45 15 100 -> 11 48 0 3 99 4 -> 0 1485 418 116 0
std::vector<std::string> data{ "Hello!", " Welcome to", " Learn"," C++ 20" };
for (char iter : data
| views::join // 注意,join不需要添加()
| views::transform([](char val) { return std::tolower(val); })) {
std::cout << iter;
}
std::cout << std::endl;
// hello! welcome to learn c++ 20
}
void Test1() {
using namespace std::ranges;
std::string str{ "Hello! Welcome to learn new feature of C++ 20" };
// 自定义范围适配器
auto newAdaptor =
views::transform([](char val) { return std::toupper(val); })
| views::filter([](char val) { return !std::isspace(val); });
for (char iter : str | newAdaptor) {
std::cout << iter;
}
// HELLO!WELCOMETOLEARNNEWFEATUREOFC++20
}
int main(int argc, char* argv[]) {
Test();
std::cout << std::endl;
Test1();
return 0;
}
Ranges对容器的排序
void Test1() {
std::vector<int> vec{ 15,18,50,2,99,14,8,33,84,78 };
// before C++20
//std::sort(vec.begin(), vec.end(), std::greater());
//std::sort(vec.begin() + 2, vec.end(), std::greater());
// C++20
// 全排序
std::ranges::sort(vec, std::ranges::less());
// 仅对第二个元素之后的所有元素进行排序
//std::ranges::sort(std::views::drop(vec, 2), std::ranges::greater());
// 反向排序
std::ranges::sort(std::views::reverse(vec))
for (auto& iter : vec) {
std::cout << iter << " ";
}
}
struct Data {
std::string name;
std::string addr;
// 升序排序
bool operator <(const Data& other)const {
return name < other.name;
}
// 降序排序
bool operator >(const Data& other)const {
return name > other.name;
};
};
void Test2() {
std::vector<Data> strVet;
strVet.emplace_back(Data{ "Jason","Jason house" });
strVet.emplace_back(Data{ "Lily","Lily house" });
strVet.emplace_back(Data{ "Mark","Mark house" });
std::ranges::sort(strVet, std::less<Data>());
for (auto& iter : strVet) {
std::cout << iter.name << " ";
}
}
int main(int argc, char* argv[]) {
Test1();
Test2();
return 0;
}
Ranges & Views 框架的实践
题目：对1-100求平方和，筛选出前5个能被4整除的数值。
思路步骤：
1）将1-100存放在std::vector
2）对容器中的每个数值求平方和；
3）筛选出所有能被4整除的数值；
4）输出前5个。
实现：
// before C++20
void Test1() {
// 筛选N个
constexpr unsigned num = 5;
std::vector<int> vet(100);
std::vector<int> newVet;
// 升序初始化
std::iota(vet.begin(), vet.end(), 1);
std::transform(vet.begin(), vet.end(), vet.begin(),
[](int val) { return val * val; }
);
std::copy_if(vet.begin(), vet.end(), std::back_inserter(newVet),
[](int val) { return val % 4 == 0; }
);
for (unsigned i = 0; i < num; i++) {
std::cout << newVet[i] << ' ';
}
// 4 16 36 64 100
}
// C++20 普通版
void Test2() {
constexpr unsigned num = 5;
std::vector<int> vec(100);
std::iota(vec.begin(), vec.end(), 1);
auto even = [](const int& a) {
return a % 4 == 0;
};
auto square = [](const int& a) {return a * a; };
for (auto iter : std::views::take(std::views::filter(std::views::transform(vec, square), even), num)) {
std::cout << iter << ' ';
}
// 4 16 36 64 100
}
// C++20 进阶版
void Test3() {
using namespace std::ranges;
constexpr unsigned num = 5;
for (auto iter : views::iota(1)
| views::transform([](int val) { return val * val; })
| views::filter([](int val) { return val % 4 == 0; })
| views::take(num)) {
std::cout << iter << ' ';
}
// 4 16 36 64 100
}
int main(int argc, char* argv[]) {
Test1();
std::cout << std::endl;
Test2();
std::cout << std::endl;
Test3();
return 0;
}
Lambda 表达式的更新
1）允许[=, this]作为Lambda捕获，并弃用此隐式捕获[=]；
2）Lambda init-capture 中的包扩展：...args = std::move(args)](){}；
3）static, thread_local, 和 Lambda 捕获结构化绑定；
4）模板形式 Lambda。
模板形式的 Lambda 表达式
// Before C++20 获取 vector 元素类型
auto func = [](auto vec){
using T = typename decltype(vec)::value_type;
}
// C++20
auto func = []<typename T>(vector<T> vec){
// ...
}
Lambda 表达式捕获支持打包展开
// Before C++20
template<class F, class... Args>
auto delay_invoke(F f, Args... args){
return [f, args...]{
return std::invoke(f, args...);
}
}
// C++20
template<class F, class... Args>
auto delay_invoke(F f, Args... args){
// Pack Expansion: args = std::move(args)...
return [f = std::move(f), args = std::move(args)...](){
return std::invoke(f, args...);
}
}
原子(Atomic)智能指针
智能指针(shared_ptr)线程安全吗?
是: 引用计数控制单元线程安全, 保证对象只被释放一次
否: 对于数据的读写没有线程安全
如何将智能指针变成线程安全?
1）使用 mutex 控制智能指针的访问
2）使用全局非成员原子操作函数访问, 诸如: std::atomic_load(), atomic_store(), …
缺点: 容易出错, 开发过程中容易遗漏添加这些操作。
C++20提供了原子智能指针，比如：atomic<shared_ptr
内部原理可能使用了mutex；
全局非成员原子操作函数标记为不推荐使用(deprecated)
详情请参见：
shared_ptr的线程安全性
std::atomic(std::shared_ptr)
例子：
template<typename T>
class concurrent_stack {
struct Node {
T t;
shared_ptr<Node> next;
};
atomic_shared_ptr<Node> head;
// C++11: 去掉 "atomic_" 并且在访问时, 需要用
// 特殊的函数控制线程安全, 例如用std::tomic_load
public:
class reference {
shared_ptr<Node> p;
<snip>
};
auto find(T t) const {
auto p = head.load(); // C++11: atomic_load(&head)
while (p && p->t != t)
p = p->next;
return reference(move(p));
}
auto front() const {
return reference(head);
}
void push_front(T t) {
auto p = make_shared<Node>();
p->t = t; p->next = head;
while (!head.compare_exchange_weak(p->next, p)){
} // C++11: atomic_compare_exchange_weak(&head, &p->next, p); }
void pop_front() {
auto p = head.load();
while (p && !head.compare_exchange_weak(p, p->next)) {
} // C++11: atomic_compare_exchange_weak(&head, &p, p->next);
}
};
上述例子来自 Herb Sutter 的 N4162 论文
自动合流(Joining), 可协作中断(Cancellable) 的线程
std::jthread对象包含std::thread一个成员，提供完全相同的公共函数，这些函数只是向下传递调用。这使我们可以将任何内容更改std::thread为std::jthread，确保它将像以前一样工作。
自动合流(Joining)
C++20 在线程thread中新增了std::jthread。
功能：
1）支持中断；
2）析构函数中自动调用 join()；
3）析构函数调用 stop_source.request_stop() 然后 join()。
例子：
// Before C++20
void Test() {
std::thread th;
{
th = std::thread([]() {
for (unsigned i = 1; i < 10; ++i) {
std::cout << i << " ";
Sleep(500);
}
});
}
// 如果没有join()，直接退出就会引发崩溃
// th.join();
}
// C++20
void Test1() {
std::jthread th;
{
th = std::jthread([]() {
for (unsigned i = 1; i < 10; ++i) {
std::cout << i << " ";
Sleep(500);
}
});
}
// 没有使用join也不会崩溃,因为std::jthread的析构函数默认调用join()
}
int main(int argc, char* argv[]) {
//Test();
std::cout << std::endl;
Test1();
return 0;
}
可协作的中断(Cancellable)
在上述例子中使用的[ for (unsigned i = 1; i < 10; ++i) ]，循环是10次；如果替换为while(1)时，整个函数就会被阻塞，阻塞在join()。因此线程没有执行结束并正常退出，此时函数join()就会一直等待下去。
在C++20中提供了可协作的中断操作，可以通过外部发起的请求，最后由线程内部决定是否中断并退出。
语法说明
std::stop_token
用来查询线程是否中断，可以和condition_variable_any配合使用
std::stop_source
用来请求线程停止运行，stop_resources 和 stop_tokens 都可以查询到停止请求
std::stop_callback
如果对应的stop_token 被要求终止, 将会触发回调函数。
用法: std::stop_callback StopTokenCallback(OnStopToken, []{ /* … */ });
例子：
void Test3() {
std::jthread th;
{
th = std::jthread([]() {
while (1) {
std::cout << "1";
Sleep(500);
}
});
}
// 外部发起中断请求，但是线程内部没有响应，仍然会阻塞
th.request_stop();
// 此句执行了，但是整个函数退出时仍会阻塞
std::cout << "Finish Test3.";
}
void Test4() {
std::jthread th;
{
th = std::jthread([](const std::stop_token st) {
while (!st.stop_requested()) {
// 没有收到中断请求，则执行
std::cout << "1";
Sleep(500);
}
});
}
Sleep(10 * 1000);
// 外部发起中断请求
auto ret = th.request_stop();
}
int main(int argc, char* argv[]) {
//Test3();
//std::cout << std::endl;
Test4();
std::cout << std::endl;
return 0;
}
三路比较运算符(<=>)
C++20之前，封装好的对象（比如类对象或结构体对象）若出现比较或排序的情况，就需要重载某个特定的运算符，有时候还需要多个不同的运算符重载。
C++20，提供了三路比较运算符，会默认生成一系列的比较运算符。生成的默认运算符有六个即：==、!=、<、>、<=、>=。
详情说明请参见：
例子：
简单来说，对比于双目运算符(:?)，多了一处相等比较的返回。
双目运算符：
a >= b ? b : a
三路运算符语法：
(a <=> b) < 0 // 如果 a < b 则为 true
(a <=> b) > 0 // 如果 a > b 则为 true
(a <=> b) == 0 // 如果 a 与 b 相等或者等价，则为 true
三路运算符展开：
auto res = a <=> b;
if (res < 0)
std::cout << "a 小于 b";
else if (res > 0)
std::cout << "a 大于 b";
else
std::cout << "a 与 b 相等";
// 类似于C的strcmp 函数返回-1, 0, 1
在C++20之前，在map中以结构信息作为Key，必须提供一个排序的仿函数。如下例子：
struct UserInfo {
std::string name;
std::string addr;
};
struct Compare {
bool operator()(const UserInfo& left, const UserInfo& right) const {
return left.name > right.name;
}
};
int main(int argc, char* argv[]) {
std::map <UserInfo, bool, Compare> infoMap;
UserInfo usr1{ "Jason","Jason1111" };
UserInfo usr2{ "Lily","Lily2222" };
UserInfo usr3{ "Mark","Mark3333" };
infoMap.insert(std::pair<UserInfo, bool>(usr2, true));
infoMap.insert(std::pair<UserInfo, bool>(usr1, false));
infoMap.insert(std::pair<UserInfo, bool>(usr3, true));
for (auto& iter : infoMap) {
std::cout << iter.first.name << std::endl;
}
return 0;
}
在C++20中，可以直接使用默认的三路比较运算符。若某运算符不满足，亦可自定义功能。如下：
struct UserInfo {
std::string name;
std::string addr;
// 默认升序
//std::strong_ordering operator<=>(const UserInfo&) const = default;
// 自定义不同的排序--降序
std::strong_ordering operator<=>(const UserInfo& info) const {
auto ret = name <=> info.name;
return ret > 0 ? std::strong_ordering::less
: (ret == 0 ? std::strong_ordering::equal : std::strong_ordering::greater);
};
};
int main(int argc, char* argv[]) {
std::map <UserInfo, bool> infoMap;
UserInfo usr1{ "Jason","Jason1111" };
UserInfo usr2{ "Lily","Lily2222" };
UserInfo usr3{ "Mark","Mark3333" };
infoMap.insert(std::pair<UserInfo, bool>(usr2, true));
infoMap.insert(std::pair<UserInfo, bool>(usr1, false));
infoMap.insert(std::pair<UserInfo, bool>(usr3, true));
for (auto& iter : infoMap) {
std::cout << iter.first.name << std::endl;
}
return 0;
}
日历(Calendar)和时区(Timezone)功能
Calendar
简单的日期时间转换
// creating a year
auto y1 = year{ 2021 };
auto y2 = 2021y;
// creating a mouth
auto m1 = month{ 9 };
auto m2 = September;
// creating a day
auto d1 = day{ 24 };
auto d2 = 24d;
weeks w{ 1 }; // 1 周
days d{ w }; // 将 1 周转换成天数
std::cout << d.count();
hours h{ d }; // 将 1 周转换成小时
std::cout << h.count();
minutes m{ w }; // 将 1 周转换成分钟
std::cout << m.count();
日期时间的计算
struct DaysAttr {
sys_days sd;
sys_days firstDayOfYear;
sys_days lastDayOfYear;
year y;
month m;
day d;
weekday wd;
};
DaysAttr GetCurrentDaysAttr() {
// 目的获取今年的第一天和最后一天，统一初始化
DaysAttr attr;
attr.sd = floor<days>(system_clock::now());
year_month_day ymd = attr.sd;
attr.y = ymd.year();
attr.m = ymd.month();
attr.d = ymd.day();
attr.wd = attr.sd;
attr.firstDayOfYear = attr.y / 1 / 1;
attr.lastDayOfYear = attr.y / 12 / 31;
return attr;
}
// 一年中过去的天数，以及一年中剩余的天数
void OverDaysOfYear() {
// 这会打印出一年中的天数，其中1月1日为第1天，然后还会打印出该年中剩余的天数（不包括）sd。执行此操作的计算量很小。
// 将每个结果除以days{1}一种方法可以提取整整类型中的天数dn并将其dl分成整数，以进行格式化。
auto arrt = GetCurrentDaysAttr();
auto dn = arrt.sd - arrt.firstDayOfYear + days{ 1 };
auto dl = arrt.lastDayOfYear - arrt.sd;
std::cout << "It is day number " << dn / days{ 1 } << " of the year, "
<< dl / days{ 1 } << " days left." << std::endl;
}
// 该工作日数和一年中的工作日总数
void WorkDaysOfYear() {
// wd是|attr.wd = attr.sd|计算的星期几（星期一至星期日）。
// 要执行这个计算，我们首先需要的第一个和最后一个日期wd的当年y。|arrt.y / 1 / arrt.wd[1]|是wd一月的第一个，|arrt.y / 12 / arrt.wd[last]|则是wd十二月的最后一个。
// wd一年中的总数仅是这两个日期之间的周数（加1）。子表达式[lastWd - firstWd]是两个日期之间的天数。将该结果除以1周将得到一个整数类型，该整数类型保存两个日期之间的周数。
// 星期数的计算方法与星期总数的计算方法相同，不同的是星期数从当天开始而不是wd一年的最后一天开始|sd - firstWd|。
auto arrt = GetCurrentDaysAttr();
sys_days firstWd = arrt.y / 1 / arrt.wd[1];
sys_days lastWd = arrt.y / 12 / arrt.wd[last];
auto totalWd = (lastWd - firstWd) / weeks{ 1 } + 1;
auto n_wd = (arrt.sd - firstWd) / weeks{ 1 } + 1;
std::cout << format("It is {:%A} number ", arrt.wd) << n_wd << " out of "
<< totalWd << format(" in {:%Y}.}", arrt.y) << std::endl;;
}
// 该工作日数和一个月中的工作日总数
void WorkDaysAndMonthOfYear() {
// 从wd年月对的第一个和最后一个开始|arrt.y / arrt.m|,而不是整个全年开始
auto arrt = GetCurrentDaysAttr();
sys_days firstWd = arrt.y / arrt.m / arrt.wd[1];
sys_days lastWd = arrt.y / arrt.m / arrt.wd[last];
auto totalWd = (lastWd - firstWd) / weeks{ 1 } + 1;
auto numWd = (arrt.sd - firstWd) / weeks{ 1 } + 1;
std::cout << format("It is {:%A} number }", arrt.wd) << numWd << " out of "
<< totalWd << format(" in {:%B %Y}.", arrt.y / arrt.m) << std::endl;;
}
// 一年中的天数
void DaysOfYear() {
auto arrt = GetCurrentDaysAttr();
auto total_days = arrt.lastDayOfYear - arrt.firstDayOfYear + days{ 1 };
std::cout << format("Year {:%Y} has ", y) << total_days / days{ 1 } << " days." << std::endl;;
}
// 一个月中的天数
void DaysOfMonth() {
// 表达式|arrt.y / arrt.m / last|是年份-月份对的最后一天,|arrt.y / arrt.m|就是|arrt.y / arrt.m / 1|月份的第一天。
// 两者都转换为sys_days，因此可以减去它们以得到它们之间的天数。从1开始的计数加1。
auto arrt = GetCurrentDaysAttr();
auto totalDay = sys_days{ arrt.y / arrt.m / last } - sys_days{ arrt.y / arrt.m / 1 } + days{ 1 };
std::cout << format("{:%B %Y} has ", arrt.y / arrt.m) << totalDay / days{ 1 } << " days." << std::endl;;
}
语法初始化
对于部分不喜欢“常规语法”的开发者，可以使用完整的“构造函数语法”来代替。
例如：
sys_days newYear = y/1/1;
sys_days firstWd = y/1/wd[1];
sys_days lastWd = y/12/wd[last];
可以替换为：
sys_days newYear = year_month_day{y, month{1}, day{1}};
sys_days firstWd = year_month_weekday{y, month{1}, weekday_indexed{wd, 1}};
sys_days lastWd = year_month_weekday_last{y, month{12}, weekday_last{wd}};
Timezone
time_zone表示特定地理区域的所有时区转换。
C++语言标准记得选择：/std:c++latest
例子：
int main()
{
constexpr std::string_view locations[] = {
"Africa/Casablanca", "America/Argentina/Buenos_Aires",
"America/Barbados", "America/Indiana/Petersburg",
"America/Tarasco_Bar", "Antarctica/Casey",
"Antarctica/Vostok", "Asia/Magadan",
"Asia/Manila", "Asia/Shanghai",
"Asia/Tokyo", "Atlantic/Bermuda",
"Australia/Darwin", "Europe/Isle_of_Man",
"Europe/Laputa", "Indian/Christmas",
"Indian/Cocos", "Pacific/Galapagos",
};
constexpr auto width = std::ranges::max_element(locations, {},
[](const auto& s) { return s.length(); })->length();
for (const auto location : locations) {
try {
// may throw if `location` is not in the time zone database
const std::chrono::zoned_time zt{location, std::chrono::system_clock::now()};
std::cout << std::setw(width) << location << " - Zoned Time: " << zt << '\n';
} catch (std::chrono::nonexistent_local_time& ex) {
std::cout << "Error: " << ex.what() << '\n';
}
}
}
consteval 与 constinit
constexpr
既能参与函数的声明，又能参与变量的声明
constexpr可用于编译或运行时函数，它的结果是常量。
constexpr的主要作用是声明变量的值或函数的返回值可以在常量表达式（即编译期便可计算出值的表达式）中使用。
int Func() {
return 1;
}
// 可修改为
//constexpr int Func() {
// return 1;
//}
constexpr const int x = 5; // OK
constexpr const int y = Func(); // Error
consteval
只能参与函数的声明
当某个函数使用consteval声明后，则所有带有求值的操作，来调用这个函数的表达式时，必须为常量表达式。
实际上是编译时运行的函数，也就是它的参数在编译时是“确定的”（常量），它的结果也是常量。
例子：
consteval int Test1(int val) {
return ++val;
}
constexpr int Test2(int val) {
return ++val;
}
int main(int argc, char* argv[]) {
int ret = Test1(10);
std::cout << ret << std::endl;
//int val = Test1(ret); //error , ret is not const
int val = Test2(ret);
std::cout << val;
return 0;
}
如上例子所示：
ret是函数返回的变量，而由consteval定义的函数必须在编译时可运行出常量结果，因此冲突了。int val = Test1(ret)无法被调用。
constexpr既可在编译时也是可以在运行时，因此可以接受变量参数。
constinit
只能参与变量的声明
constinit只能用于static或thread_local，不能与constexpr、consteval一起使用。
constinit的作用在于显式地指定变量的初始化方式为静态初始化。
其生命周期必须为静态生命周期或线程本地（Thread-local）生命周期（即不能为局部变量），其初始化表达式必须是一个常量表达式。
constexpr的变量是const类型，只读，不能二次修改；constinit是说变量在程序开始时被初始化，是static类型，不能在运行时被创建，变量不要求是const类型，可以被二次修改。
例子：
consteval int Test1() {
return 1;
}
int Test2() {
return 2;
}
void Test3() {
constinit int e = 20; // Error: e is not static
}
constinit int a = 100; // OK
constinit int b = Test1(); // OK，run time
constinit thread_local int c = 200; // OK
constinit int d = Test2(); // Error: `Test2()` is not a constant expression
int Test4() {
// constinit can be modified
a += 200; // run time
b = 2000;
c -= 50;
return a;
}
用 using 引用 enum 类型
enum class Color {
kRed,
kBlue,
kGreen,
};
// before C++20
std::string_view Color2String(const Color color) {
switch (color) {
case Color::kRed:
return "Red";
case Color::kBlue:
return "Blue";
case Color::kGreen:
return "Green";
}
return "Red";
}
// C++20
std::string_view Color2String(const Color color) {
switch (color) {
using enum Color; // feature
case kRed:
return "Red";
case kBlue:
return "Blue";
case kGreen:
return "Green";
}
return "Red";
}
实现枚举量值与枚举量值的映射，推荐一个专门处理enum转化的库----Better Enums
