目录
1 关键字
1.1 concept
1.2 requires
1.3 typename
1.4 explicit
1.5 constexpr
1.6 char8_t
1.7 consteval
1.8 co_await、co_yield、co_return
1.9 constinit
2 语法
2.1 位域变量的默认成员初始化
2.2 修改const限定的成员指针
2.3 允许lambda表达值按值捕获this
2.4 指定初始化
2.5 lambda表达式支持模板
2.6 从构造函数推导出模板参数类型
2.7 基于范围的for循环初始化
2.8 简化lambda的隐式捕获
2.9 ADL与不可见的模板函数
2.10 operator<=>
2.11 基于范围的for循环初始化
2.12 默认可构造可分配的无状态lambdas
2.13 专门的访问检查
2.14 constexpr函数的实例化
2.15 允许lambda在初始化捕获时进行包扩展
2.16 放宽结构化绑定，新增自定义查找规则
2.17 放宽基于范围的for循环，新增自定义范围方法
2.18 类类型的非类型模板参数
关于类类型的非类型模板参数的优化
类类型的非类型模板参数的条件（满足任意一个）：
2.19 禁止使用用户自己声明的构造函数来进行聚合初始化
旧版的几个问题
解决方案
2.20 嵌套内联命名空间
2.21 约束声明的另一种办法
2.22 允许在常量表达式中使用dynamic_cast多台typeid
2.23 允许用圆括弧的值进行聚合初始化
2.24 new表达式的数组元素个数的推导
2.25 unicode字符串字面量
2.26 允许转换成未知边界的数组
2.27 聚合初始化推导类模板参数
2.28 隐式地将返回的本地变量转换为右值引用
2.29 允许default修饰运算符按值比较
2.30 非类型模板参数等效的条件
3 宏
4 属性
4.1 likely和unlikely
4.2 no_unique_address
4.3 nodiscard
5 弃用
5.1 lambda弃用使用[=]来隐式捕获this
5.2 比较运算符的改进
5.3 弃用下标表达式中的逗号操作符
后记
C++20
编译器版本：GCC 10
__cplusplus：待定
编译选项：-std=c++2a
1 关键字
1.1 concept
concept乃重头戏之一，用于模板库的开发。功能类似于C#的泛型约束，但是比C#泛型约束更为强大。
concept用于声明具有特定约束条件的模板类型。
例子：数值类型约束
cpp
#include <type_traits>
// 声明一个数值类型的concept
template<typename T>
concept number = std::is_arithmetic<T>::value; // 对模板类型T添加std::is_arithmetic<T>::value为true的约束，并对具有约束的新的类型声明number
// 使用具有约束的类型，调用该函数时，T类型必须符合std::is_arithmetic<T>::value等于true，否则编译报错
template<number T>
void func(T t)
{ }
// 调用
func<int>(10); // 正确，std::is_arithmetic<int>::value为true
func<double>(20.0); // 正确，std::is_arithmetic<double>::value为true
struct A
{ };
func<A>(A()); // 错误，std::is_arithmetic<A>::value为false1.2 requires
单纯一个concept还不够强大，真正让concept起飞的是这个requires，concept结合requires之后，对模板类型参数的约束可以细致到类型成员变量、类型成员函数甚至其返回值等等。
例子：约束类型具有指定名称的成员变量、成员函数
cpp
#include <type_traits>
template<typename T>
concept can_run = requires(T t)
{
std::is_class<T>::value; // T是一个类型
t(); // T类型有重载括号运算符，且是无参的
t.run(); // T类型具有run()成员函数
std::is_same<decltype(t.run()), int>::value; // T类型的run()函数的返回值为int类型
}
// concepts类型使用
template<can_run T>
int func(T t)
{
t();
return t.run(); // run()函数的返回值已被限定为int类型，所以此处可直接返回
}
func<int>(10); // 错误，这不是一个class或struct
struct A
{
void run() { }
}
func<A>(A()); // 编译错误，没有重载括号运算符
struct B
{
void operator()() { }
}
func<B>(B()); // 编译错误，没有run()函数
struct C
{
void operator()() { }
void run() { }
}
func<C>(C()); // 编译错误，run()函数返回值不是int类型
struct D
{
int operator()() { }
int run() { return 0; }
}
func<D>(D()); // 正确，编译通过1.3 typename
typename主要两种用法：①模板类型声明②声明一个名称是类型名。此前为了解决冲突问题，功能②被大量地使用，新版本为了提高可读性，加强了编译的推导能力，简化typename在功能②的使用。
在一些地方，例如在某指定的上下文中只能推导为类型的地方，可不加typename。
例子：
cpp
// 函数的返回值，在全局范围内只可能是一种类型，所以可不加typename
template<class T> T::R f(); // OK, return type of a function declaration at global scope
// 作为函数的参数，
template<class T> void f(T::R); // Ill-formed (no diagnostic required), attempt to declare a void variable template
template<typename T>
struct PtrTraits
{
typedef T* Ptr;
};
template<class T>
struct S
{
using Ptr = PtrTraits<T>::Ptr; // OK, in a defining-type-id
T::R f(T::P p)
{ // OK, class scope
return static_cast<T::R>(p); // OK, type-id of a static_cast
}
auto g() -> S<T*>::Ptr;// OK, trailing-return-type
};
template<typename T> void f()
{
void (*pf)(T::X); // Variable pf of type void* initialized with T::X
void g(T::X); // Error: T::X at block scope does not denote a type
// (attempt to declare a void variable)
}1.4 explicit
新增bool参数，表示explicit本身的作用是否启用
例子：
cpp
struct A
{
explicit(false)
A(int) { }
};
struct B
{
explicit(true)
B(int) { }
};
A a = 10; // 正确
B b = 10; // 错误：将int类型转换为B类型1.5 constexpr
①扩展适用范围，新增对虚函数的支持，用法与普通函数一致，不再赘述。
②禁止constexpr函数内使用try-catch语句块。不再赘述。
1.6 char8_t
为utf-8字符编码专门打造，以后就由char8_t类型接收utf-8字面量，而不再由char接收。
编译器未完全实现，待续。
1.7 consteval
编译器未实现，待续。
1.8 co_await、co_yield、co_return
协程三件套：co_await、co_yield、co_return
由于编译器未支持，详解待续。
1.9 constinit
用于强制常量进行初始化，不可动态初始化。
变量条件：静态 或 线程存储持续时间。thread_local修饰的变量可不进行初始化
例子：
cpp
const char * get_str1()
{
return "111111";
}
constexpr const char * get_str2()
{
return "222222";
}
const char *hahah = " hhahahaa ";
constinit const char *str1 = get_str2(); // 编译正确
constinit const char *str2 = get_str1(); // 编译错误，用非constexpr函数对constinit变量进行初始化
constinit const char *str3 = hahah; // 编译错误，用非常量表达式对constinit变量进行初始化
int main()
{
static constinit const char *str4 = get_str2(); // 编译正确
constinit const char *str5 = get_str2();// 编译错误，必须是静态 或 线程存储持续时间的变量
constinit thread_local const char *str6; // 编译正确
return 0;
}2 语法
2.1 位域变量的默认成员初始化
位域变量在声明时可进行初始化。
位域变量的声明语法格式：
- 标识符 变量名 : 位数
- 标识符 变量名 : 常量表达式、大括号
例子：
cpp
int a;
const int b = 1;
struct S
{
int x1 : 8 = 42; // 正确，x1为8位的变量，并且初始化为42，"=42"为常量表达式
int x2 : 6 {42}; // 正确，x2为6位的变量，并且初始化为42
int x3 : true ? 10 : a = 20; // 正确，x3为10位变量，不进行初始化，赋值号优先于三目运算符
int x4 : true ? 10 : b = 20; // 错误，b为const变量，不可赋值
int x5 : (true ? 10 : b) = 20; // 正确，x5为10位的变量，并且初始化为20
int x6 : false ? 10 : a = 20; // 错误，a = 10不是常量表达式
};2.2 修改const限定的成员指针
在一个右值的 .* 表达式中，如果表达式的第二个参数是指向以&修饰的成员函数的指针，那么这个程序就是不规范的，除非限定符是const
例子：
cpp
struct S { void foo() const& { } };
void f()
{
S{}.foo(); // 正确，没问题
(S{}.*&S::foo)(); // C++20起支持该语法
}2.3 允许lambda表达值按值捕获this
例子：
cpp
struct S
{
int value;
void print()
{
auto f = [=, this]() {
this->value++;
};
}
}2.4 指定初始化
在构造对象时，可以指定成员进行初始化，但是初始化的顺序必须与成员的内存顺序一致。
例子：
cpp
struct A { int x, y; };
struct B { int y, x; };
void f(A a, int); // #1
void f(B b, ...); // #2
void g(A a); // #3
void g(B b); // #4
void h()
{
f({.x = 1, .y = 2}, 0); // 正确，调用#1
f({.y = 1, .x = 2}, 0); // 错误，调用#1，初始化顺序不匹配
f({.y = 1, .x = 2}, 1, 2, 3); // 正确，调用#2
g({.x = 1, .y = 2}); // 错误，无法确定调用#3还是#4
}
2.5 lambda表达式支持模板
从新版开始，lambda表达式支持模板编程，且支持自动推导。（官方的说明是：支持未鉴定的上下文）
例子1：
cpp
int a;
auto f = [&a]<typename T>(const T &m) {
a += m;
};
f(10);例子2：
cpp
template<typename T>
int func(int t)
{
return t * t;
}
int f()
{
return func<decltype([] {})>(20);
}例子3：
cpp
using A = decltype([] {});
void func(A *) { }
func(nullptr);
template<typename T>
using B = decltype([] {});
void f1(B<int> *) { }
template<typename T>
void f2(B<T> *) { }
f1(nullptr);
f2<int>(nullptr); 2.6 从构造函数推导出模板参数类型
声明变量时进行初始化，如果能从构造函数中推导出变量类型，则该变量的类型可以不用指定模板参数。
例子：
cpp
vector v{vector{1, 2}}; // 正确，v 推导为vector<vector<int>>类型
tuple t{tuple{1, 2}}; //正确，t 推导为tuple<int, int>类型2.7 基于范围的for循环初始化
直接上例子：
2.8 简化lambda的隐式捕获
本人水平有限，暂时不能展示。
2.9 ADL与不可见的模板函数
ADL是C++本来就有的机制，用于自动推断调用的函数的位置，从而简化代码的编写。而新特性扩展了ADL机制，可以用于模板函数的推断。
例子：
cpp
int h;
void g();
namespace N
{
struct A {};
template<typename T> int f(T);
template<typename T> int g(T);
template<typename T> int h(T);
}
int x = f<N::A>(N::A()); // 正确，调用N::f
int y = g<N::A>(N::A()); // 正确，调用N::g
int z = h<N::A>(N::A()); // 错误，h是变量，不是模板2.10 operator<=>
因为篇幅过长就不再在这里详细赘述了，感兴趣的可以自行查看http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0515r3.pdf。因此，我在这里只简单说一下。
来了解一下不同类型的比较策略（专有名词就不翻译了），并且可进行向下进行相对应的隐式转换：
| 策略 | 数值型结果 | 非数值型结果 |
| -1 | 0 | 1 |
| strong_ordering | less | equal | greater | unordered |
| weak_ordering | less | equivalent | greater |
| partial_ordering | less | equivalent | greater |
| strong_equality | unequal | equal | unequal |
| weak_equality | nonequivalent | equivalent | nonequivalent |
至于什么时候用到哪一种策略，这里有一位博主翻译好了的https://blog.csdn.net/qq_31359295/article/details/78799020，这里不再讲解（懒）。
2.11 基于范围的for循环初始化
新增的for循环语法格式：
for([init-statement;] for-range-declaration : for-range-initializer) ...
例子：
cpp
int a[] = {1, 2, 3, 4};
for(int b = 0; int i : a)
{
...
}2.12 默认可构造可分配的无状态lambdas
简单点说，就是可以获取lambda或函数对象的类型，并且还可以创建对象。
举个例子感受一下：
cpp
#include <iostream>
#include <map>
auto greater = [](auto x, auto y) { return x > y; };
std::map<std::string, int, decltype(greater)> map;
static void f()
{}
int main()
{
decltype(f) ff;
ff();
decltype(greater) d;
d(10, 20);
return 0;
}2.13 专门的访问检查
我能力有限，不能准确理解文档的意思。这个特性在GCC、MSVC编译器中早已实现，但在其他的编译器以前的版本中并未实现。
我的理解是，在模板类内，可以忽略访问权限而访问到其他类内的嵌套类。
例子：
cpp
class A
{
struct impl1
{ int value; };
template<typename T>
class impl2
{ T value; };
class impl3
{ int value; };
};
struct B
{
A::impl1 t; // error: 'struct A::impl1' is private within this context
};
template<typename T>
struct trait
{
A::impl1 t; // ok
A::impl2<T> t2; // ok
void func()
{
A::impl1 tmp; // ok
tmp.value = 10;// ok
t2.value = 20; // ok
A::impl3 t3; // ok
t3.value = 30; // ok
}
};
int main()
{
trait<int> a;
a.t.value = 10; // ok
a.t2.value = 20; // error: 'int A::impl2<int>::value' is private within this context
return 0;
}2.14 constexpr函数的实例化
当仅仅获取constexpr函数的返回值类型时，不对函数进行实例化，即仅推导返回值类型，而不对函数进行调用。
cpp
template<typename T>
constexpr int f()
{ return T::value; }
// 此处仅仅推导f<T>()的返回值类型
template<bool B, typename T>
void g(decltype(B ? f<T>() : 0)) { }
template<bool B, typename T> void g(...) { }
// 因为需要获取int类型的数据，所以需要执行f<T>()函数
template<bool B, typename T> void h(decltype(int{B ? f<T>() : 0})) { }
template<bool B, typename T> void h(...) { }
void x()
{
g<false, int>(0); // OK, B ? f<T>() : 0 is not potentially constant evaluated
h<false, int>(0); // error, instantiates f<int> even though B evaluates to false and
// list-initialization of int from int cannot be narrowing
}2.15 允许lambda在初始化捕获时进行包扩展
扩展了包扩展的应用范围
例子：
cpp
#include <functional>
template<class F, class... Args>
auto invoke1(F f, Args... args)
{
// 这种写法的效果跟[=]一致
return [f, args...]() -> decltype(auto)
{
return std::invoke(f, args...);
};
}
template<class F, class... Args>
auto invoke2(F f, Args... args)
{
// 注：三个点号写在参数前面
return [f=std::move(f), ...args=std::move(args)]() -> decltype(auto)
{
return std::invoke(f, args...);
};
}
template<class F, class... Args>
auto invoke3(F f, Args... args)
{
// 在初始化捕获中构造元组
return [f=std::move(f), tup=std::make_tuple(std::move(args)...)]() -> decltype(auto)
{
return std::apply(f, tup);
};
}2.16 放宽结构化绑定，新增自定义查找规则
这个特性比较地牛逼了，以前的结构化绑定的限制比较多，现在放宽了限制，并且可以自定义绑定的第几个是哪个类型，而且可以指定解绑的个数。
自定义的条件：
①在类外实现get(Type)函数、或在类内实现Type::get()成员函数；
②在std命名空间内特化tuple_size和tuple_element结构体；
③get()的返回路径数量必须与tuple_size指定的数值相等，tuple_element特化的索引数量（且必须从0开始）必须与tuple_size指定的数值相等；
④get()函数中N的值对应的返回类型必须与tuple_element对应索引指定的类型相同。
例子1：
cpp
#include <string>
#include <tuple>
struct A
{
int a;
int b;
};
struct X : private A
{
std::string value1;
std::string value2;
};
// 第一种方式，类外实现get<>()
template<int N>
auto& get(X &x)
{
if constexpr (N == 0)
return x.value2;
}
namespace std
{
// 指定结构化绑定数量为1个
template<>
class tuple_size<X>
: public std::integral_constant<int, 1>
{};
// 指定结构化绑定的第一种类型为string
template<>
class tuple_element<0, X>
{
public:
using type = std::string;
};
}
int main()
{
X x;
auto& [y] = x;// y的类型为string
auto& [y1, y2] = x; // error: 2 names provided for structured binding, while 'X' decomposes into 1 element
return 0;
}例子2：
cpp
#include <string>
#include <tuple> // 必须包含tuple库
struct A
{
int a;
int b;
};
struct X : protected A
{
std::string value1;
std::string value2;
// 第二种方式，在类内实现get<>
template<int N>
auto& get()
{
if constexpr (N == 0)
return value1;
else if constexpr (N == 1)
return a;
}
};
namespace std
{
// 指定X类型结构化绑定的个数为2个
template<>
class tuple_size<X>
: public std::integral_constant<int, 2>
{};
// 指定第一种类型为string类型
template<>
class tuple_element<0, X>
{
public:
using type = std::string;
};
// 指定第二种类型为int类型
template<>
class tuple_element<1, X>
{
public:
using type = int;
};
}
int main()
{
X x;
auto& [y1, y2] = x; // y1为string类型，y2为int类型
return 0;
}2.17 放宽基于范围的for循环，新增自定义范围方法
以前的版本自定义类的for循环，需要实现begin()和end()的成员函数；新版本开始，可以不实现成员函数，而在类体外实现begin()和end()，具体看以下例子
例子：
cpp
#include <iostream>
struct X
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
};
int* begin(X& x)
{
return reinterpret_cast<int*>(&x);
}
int* end(X& x)
{
return reinterpret_cast<int*>(&x) + sizeof(x) / sizeof(int);
}
int main()
{
X x;
for (int i : x)
{
std::cout << i << std::endl;
}
std::cout << "finish" << std::endl;
return 0;
}2.18 类类型的非类型模板参数
比较拗口，放松了非类型模板参数的限制，可以用类类型作为模板的参数，但是条件是所需要的运算需要在编译期完成。
如下例：
cpp
#include <iostream>
struct A
{
int value;
// 这里的constexpr是必须的
constexpr bool operator==(const A &v) const
{ return value == v.value; }
};
template<A a, A b>
struct Equal
{
static constexpr bool value = a == b;// 需要在编译期调用operator==
};
int main()
{
static constexpr A a{10}, b{20}; // 作为模板的传入参数，也必须是常量
std::cout << std::boolalpha << Equal<a, b>::value << std::endl; // 输出false
std::cout << std::boolalpha << Equal<a, a>::value << std::endl; // 输出true
return 0;
}关于类类型的非类型模板参数的优化
①operator==的缺口
直接看例子，文字不好写
cpp
#include <iostream>
template<auto v>
int Value;
struct A
{
int value;
};
int main()
{
static constexpr A a{10}, b{20}, c{10};
// 对于Value<a>和Value<b>，只要 (a<=>b) == 0，则&Value<a> == &Value<b>结果就true.
// 关于 <=> 运算符可以往上面看
std::cout << std::boolalpha << (&Value<a> == &Value<b>) << std::endl; // 输出false
std::cout << std::boolalpha << (&Value<a> == &Value<c>) << std::endl; // 输出true
return 0;
}②模板参数的成员函数调用
因为模板参数是处于编译期计算的，因此，作为调用用于自定义类型的模板参数的成员函数时，这些成员必须是constexpr修饰的。
③类模板参数的相互推导
例子：
cpp
#include <string>
template<typename _Tp, std::size_t N>
struct MyArray
{
constexpr MyArray(const _Tp (&foo)[N + 1])
{ std::copy_n(foo, N + 1, m_data); }
auto operator<=>(const MyArray &, const MyArray &) = default;
_Tp m_data[N];
};
template<typename _Tp, std::size_t N>
MyArray(const _Tp (&str)[N] -> MyArray<_Tp, N - 1>;
template<std::size_t N>
using CharArray = MyArray<char, N>;
// 在此例子中，用"hello"字符串去实例化A模板时，需要显式的提供size，这导致比较大的不便
template <std::size_t N, CharArray<N> Str>
struct A {};
using hello_A = A<5, "hello">;
// 既然这是编译期常量，那在编译期是可以计算出来的，因此C++20做了优化
template <CharArray Str>
struct B {};
using hello_B = B<"hello">;④用户自定义字面量
引用上一个例子
cpp
template <CharArray Str>
auto operator"" _udl();
"hello"_udl; // 等价于operator""_udl<"hello">()类类型的非类型模板参数的条件（满足任意一个）：
①字面量
②是一个lvalue
③包含占位符的类型
④派生类类型的一个占位符
⑤拥有强结构可比较性，没有mutable或者volatile修饰的子对象，拥有声明为public且指定为default的operator<=>
关于强结构可比较性的定义：
对于任意一种类型T，const T的一个glvalue对象x，x<=>x是类型std::strong_ordering或者std::strong_equality的有效表达式，它既不调用三向比较操作符，也不调用结构比较运算符。
2.19 禁止使用用户自己声明的构造函数来进行聚合初始化
旧版的几个问题
①delete了构造函数，却依然可以实例化
cpp
struct X
{
X() = delete;
};
int main()
{
X x1; // 错误，无参构造函数为delete
X x2{}; // 编译通过了（问题一，实际上应该编译不通过才对）
return 0;
}②双重聚合初始化
cpp
struct X
{
int i{4};
X() = default;
};
int main()
{
X x1(3); // 错误，没有带int类型的构造函数
X x2{3}; // 编译通过，（问题二，非静态数据成员的双重聚合初始化）
return 0;
}③类外指定构造函数default
cpp
struct X
{
int i;
X() = default;
};
struct Y
{
int i;
Y();
};
Y::Y() = default;
int main()
{
X x{4}; // 正常，编译通过
Y y{4}; // 编译不通过（问题三，Y结构被判定为非聚合结构）
return 0;
}解决方案
简化并统一初始化语义
如果用户显式声明了非移动和拷贝构造函数的其他构造函数，则类的对象必须通过其中一个构造函数进行初始化。
上面三个问题的修正结果：
struct X
{
X() = delete;
};
int main()
{
X x1; // 编译错误，无参构造函数为delete
X x2{}; // 编译错误，无参构造函数为delete
return 0;
}
struct X
{
int i{4};
X() = default;
};
int main()
{
X x1(3); // 错误，没有X::X(int)构造函数
X x2{3}; // 错误，没有X::X({...})构造函数
return 0;
}
#include <initializer_list>
//--------------------//
struct X
{
int i;
X() = default;
};
struct Y
{
int i;
Y();
};
Y::Y() = default;
//--------------------//
struct A
{
int i;
A(int);
};
struct B
{
int i;
B(int);
};
B::B(int){};
struct C
{
int i;
C() = default;
C(std::initializer_list<int> list);
};
int main()
{
X x{4}; // 编译错误，没有X::X({...})构造函数
Y y{4}; // 编译错误，没有X::X({...})构造函数
A a{5}; // 编译通过
B b{5}; // 编译通过
C c{6}; // 编译通过
return 0;
}
2.20 嵌套内联命名空间
简化内联命名空间的嵌套语法
旧例子：
cpp
#include <iostream>
namespace A
{
inline namespace B
{
void func()
{
std::cout << "B::func()" << std::endl;
}
} // namespace B
} // namespace A
int main()
{
A::func(); // 输出 B::func()
return 0;
}新特性例子：
cpp
#include <iostream>
namespace A
{
namespace B
{
void func()
{
std::cout << "B::func()" << std::endl;
}
} // namespace B
} // namespace A
namespace A::inline C
{
void func()
{
std::cout << "C::func()" << std::endl;
}
} // namespace C
int main()
{
A::func(); // 输出C::func()
return 0;
}2.21 约束声明的另一种办法
利用concept与auto的特性，增加了新的约束声明方法。
例子：
cpp
#include <iostream>
struct Compare
{
// 无约束，用auto代替模板类型
bool operator()(const auto &t1, const auto &t2) const
{ return t1 < t2; }
};
template<typename T>
concept CanCompare = requires(T t){
t * t; // T类型需要提供*运算符
Compare().operator()(T(), T()); // 根据Compare结果体，需要T类型提供<运算符
};
// concept与auto的结合
CanCompare auto pow2(CanCompare auto x)
{
CanCompare auto y = x * x;
return y;
}
struct A
{
int value = 0;
bool operator<(const A &a) const
{ return value < a.value; }
A operator*(const A &a) const
{ return {.value = a.value * this->value}; }
};
int main()
{
A a;
a.value = 100;
A aa = pow2(a);// 推导参数x为A类型，A类型符合CanCompare约束，编译通过
std::cout << aa.value << std::endl;
return 0;
}2.22 允许在常量表达式中使用dynamic_cast多台typeid
待续
2.23 允许用圆括弧的值进行聚合初始化
简单地说，就是相当于默认有一个有全部非静态数据成员的构造函数。前提条件：目标类型必须符合聚合初始化的条件。
例子：
cpp
#include <iostream>
struct A
{
int v;
};
struct B
{
int a;
double b;
A &&c;
long long &&d;
};
A get()
{
return A();
}
int main()
{
int i = 100;
B b1{1, 20.0, A(), 200}; // 编译通过
B b2(1, 20.0, A(), 300); // 编译通过
B b3{1, 20.0, get(), 300}; // 编译通过
B b4(2, 30.0, std::move(get()), std::move(i));// 编译通过
return 0;
}2.24 new表达式的数组元素个数的推导
从C++20起，new表达式支持数组元素个数的自动推导。
例子：
cpp
#include <iostream>
#include <cstring>
int main()
{
double a[]{1,2,3}; // 普通的做法
double *p = new double[]{1,2,3}; // 编译通过
p = new double[0]{}; // 编译通过
p = new double[]{}; // 编译通过
char *d = new char[]{"Hello"}; // 编译通过
int size = std::strlen(d);
std::cout << size << std::endl; // 输出5
return 0;
}2.25 unicode字符串字面量
新增两种字面量，分别是utf-16和utf-32编码字符串字面量
例子：
cpp
#include <string>
int main()
{
std::u16string str1 = u"aaaaaa"; // 小写u是utf-16字符串
std::u32string str2 = U"bbbbbb"; // 大写U是utf-32字符串
return 0;
}2.26 允许转换成未知边界的数组
这个特性比较简单，在实参为数组的传参时形参可以是无边界的数组。
例子：
cpp
template<typename T>
static void func(T (&arr)[])
{
}
template<typename T>
static void func(T (&&arr)[])
{
}
int main()
{
int a[3];
int b[6];
func<int>(a);
func<int>(b);
func<int>({1, 2, 3, 4});
func<double>({1.0, 2, 3, 4, 8.0});
return 0;
}乍一看，好像很鸡肋的特性，不知道数组的长度，长度无法获取，数组的遍历不知道终点，暂时不清楚应用场景。
2.27 聚合初始化推导类模板参数
通过聚合初始化中的参数类型 来 推导出类模板参数类型
例子：
cpp
template <typename T>
struct S
{
T x;
T y;
};
template <typename T>
struct C
{
S<T> s;
T t;
};
template <typename T>
struct D
{
S<int> s;
T t;
};
C c1 = {1, 2}; // error: deduction failed
C c2 = {1, 2, 3}; // error: deduction failed
C c3 = {{1u, 2u}, 3}; // OK, C<int> deduced
D d1 = {1, 2}; // error: deduction failed
D d2 = {1, 2, 3}; // OK, braces elided, D<int> deduced
template <typename T>
struct I
{
using type = T;
};
template <typename T>
struct E
{
typename I<T>::type i;
T t;
};
E e1 = {1, 2}; // OK, E<int> deduced2.28 隐式地将返回的本地变量转换为右值引用
在以下的复制操作中，将会隐式采用移动操作代替复制操作的情况：
①如果return或co_return中的表达式是一个id-expression，其是在函数的最内层语句块或lambda表达式的主体或者参数声明子句中声明的隐式可移动实体。
②throw表达式的一个隐式可移动实体id-expression，其范围不超出最内层try块 或 [复合语句或构造函数初始值包含该throw表达式的函数try块(如果有)] 的复合语句。
例子：
cpp
#include <iostream>
struct base {
base() {}
base(const base &)
{ std::cout << "base(const base &)" << std::endl; }
private:
base(base &&)
{ std::cout << "base(base &&)" << std::endl; }
};
struct derived : base {};
base f() {
base b;
throw b; // move
derived d;
return d;
}
int main()
{
try
{
f();
}
catch(base)
{ }
return 0;
}2.29 允许default修饰运算符按值比较
直接例子：
cpp
struct C
{
// 参数为按值传递
friend bool operator==(C, C) = default; // C++20起支持
};2.30 非类型模板参数等效的条件
相同类型的两个值，模板参数等效的条件（之一）：
①整型且值相同；
②浮点类型且值相同；
③是std::nullptr_t类型；
④枚举类型，且枚举值相同；
⑤指针类型，且指针值相同；
⑥指向成员的指针类型，且引用相同的类成员，或者都是空成员指针值；
⑦引用类型，且引用相同的对象或函数；
⑧数组类型，对应元素满足模板参数等效；
⑨共用体类型，或者都没有活动成员，或者都具有相同的活动成员，且活动成员都是满足模板参数等效；
⑩类类型，且对应的直接子对象和引用成员满足模板参数等效。
3 宏
无。
4 属性
4.1 likely和unlikely
该属性用于指示switch分支结构的优化，likely表示"很大可能"落到指定分支，而unlikely表示"很小概率"落到指定分支。
例子：
cpp
int f(int i)
{
switch(i) {
case 1: [[fallthrough]];
[[likely]] case 2: return 1;
[[unlikely]] case 3: return 2;
}
return 4;
}4.2 no_unique_address
这个属性比较的复杂，有以下特性：
①同类型的子对象或成员不占用同一个地址；
②当地址不够分配时，则按照一般做法扩展空间，继续为未分配地址的no_unique_address属性成员分配地址，直至全部分配完毕；
③该属性对空类型（没有非静态数据成员）有效。
例子1：
cpp
#include <iostream>
struct A
{ }; // 空类型
struct B
{
long long v;
[[no_unique_address]] C a, b;
};
int main()
{
B b;
std::cout << &b.v << std::endl; // 输出v地址
std::cout << &b.a << std::endl; // a地址为 &v + 1
std::cout << &b.b << std::endl; // b地址为 &v + 2
std::cout << sizeof(B) << std::endl; // 输出 8
return 0;
}例子2：
cpp
#include <iostream>
struct A
{ }; // 空对象
struct B
{
int v;
[[no_unique_address]] A a, b, c, d, e, f, g;
};
int main()
{
B b;
std::cout << &b.v << std::endl; // 得到v地址
std::cout << &b.a << std::endl; // a地址为 &v + 1
std::cout << &b.b << std::endl; // a地址为 &v + 2
std::cout << &b.c << std::endl; // a地址为 &v + 3
std::cout << &b.d << std::endl; // a地址为 &v + 4
std::cout << &b.e << std::endl; // a地址为 &v + 5
std::cout << &b.g << std::endl; // a地址为 &v + 6
std::cout << &b.f << std::endl; // a地址为 &v + 7
// 由于空间不足，按照一般的内存对齐方式自动扩展空间
std::cout << sizeof(B) << std::endl; // 输出 8
return 0;
}例子3：
cpp
#include <iostream>
struct A
{ [[no_unique_address]] int value; };
struct B
{
int v;
[[no_unique_address]] A a, b, c;
};
int main()
{
B b;
std::cout << &b.v << std::endl; // 得到v地址
std::cout << &b.a << std::endl; // a地址为 &v + 4
std::cout << &b.b << std::endl; // a地址为 &v + 8
std::cout << &b.c << std::endl; // a地址为 &v + 12
std::cout << sizeof(B) << std::endl;// 输出16
return 0;
}
4.3 nodiscard
新增可选信息
例子：
cpp
[[nodiscard("asdfasfa")]]
const char * get()
{
return "";
}
int main()
{
get(); // warning: ignoring return value of 'const char* get()', declared with attribute 'nodiscard': 'asdfasfa' [-Wunused-result]
return 0;
}5 弃用
5.1 lambda弃用使用[=]来隐式捕获this
cpp
struct X
{
int x;
void foo(int n)
{
auto f = [=]() { x = n; }; // 弃用：此处的x是this->x，而非拷贝
auto g = [=, this]() { x = n; }; // 新版推荐的方法
}
};5.2 比较运算符的改进
①弃用枚举的隐式算术转换
cpp
enum E1 { e };
enum E2 { f };
int main()
{
bool b = e <= 3.7; // deprecated
int k = f - e; // deprecated
auto cmp = e <=> f; // ill-formed
return 0;
}②数组的比较
cpp
int arr1[5];
int arr2[5];
bool same = arr1 == arr2; // deprecated, 效果与&arr1[0] == &arr2[0]相同，并非比较数组内容
auto cmp = arr1 <=> arr2; // ill-formed5.3 弃用下标表达式中的逗号操作符
在下标访问时，弃用逗号分隔的多个参数的语法。
如例子：
cpp
int main()
{
int a[3]{0, 1, 3};
// 在如下的逗号操作符中，只保留最后一个有效，这个特性不变
int tmp1 = a[4, 1]; // tmp1 = a[1] = 1
int tmp2 = a[10, 1, 2]; // tmp2 = a[2] = 3
return 0;
}后记
关于C++20新特性的英文文档本人已提供免费下载，感兴趣的可以自行下载：https://download.csdn.net/download/qq811299838/12554178
我的内容只是展示应用层面，而不对新特性的目标进行阐述，因为这样子可以少写很多字。
另外，如有问题，欢迎指出。