原文详见：C++ 20: The Core Language

在上篇文章 C++20：四大件 中，我们对概念(concepts)、范围(ranges)、协程(coroutines)以及模块(modules)做了简要的介绍。当然，C++20 提供了很多东西。今天，让我们来继续了解一下核心语言(Core Language)部分。

核心语言(Core Language)

通过查看上图，便可知道我将要介绍的特性。

三路比较运算符 <=>

三路比较运算符 <=> 通常被戏称为飞船运算符。它用来确定两个值 A 和 B 到底是 A < B , A = B 还是 A > B。
你只需要礼貌地提出要求，编译器就可以自动生成三路比较运算符。在本例中，你将获得所有六个比较操作符，即 ==、!=、<、<=、> 和 >=。

#include <compare>
struct MyInt {
  int value;
  MyInt(int value): value{value} { }
  auto operator<=>(const MyInt&) const = default;
};

操作符 <=> 默认执行字典序比较，它按照基类从左到右的顺序，并按字段声明顺序对非静态成员进行比较。下面是一个摘自微软博客的相当复杂的例子：Simplify Your Code with Rocket Science: C++ 20's Spaceship Operator

struct Basics {
  int i;
  char c;
  float f;
  double d;
  auto operator<=>(const Basics&) const = default;
};
 
struct Arrays {
  int ai[1];
  char ac[2];
  float af[3];
  double ad[2][2];
  auto operator<=>(const Arrays&) const = default;
};
 
struct Bases : Basics, Arrays {
  auto operator<=>(const Bases&) const = default;
};
 
int main() 
{
  constexpr Bases a = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  constexpr Bases b = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  static_assert(a == b);
  static_assert(!(a != b));
  static_assert(!(a < b));
  static_assert(a <= b);
  static_assert(!(a > b));
  static_assert(a >= b);
}

我认为，这个代码片段中最复杂的部分不是飞船运算符，而是它使用了聚合初始化来初始化 Bases。聚合初始化也就意味着：如果所有成员都是公有的，那么你可以直接初始化类类型(类、结构或联合)的成员。在本例中使用了大括号初始化列表(braced-initialisation-list)来做这件事。关于聚合初始化的细节详见：聚合初始化。

将字符串字面值作为模板参数

在 C++20 之前，你不能使用字符串作为非类型模板参数。在 C++20 中，你可以使用它。其思想是使用标准定义的 basic_fixed_string 类型， basic_fixed_string 具有一个 constexpr 构造函数。constexpr 构造函数允许它在编译时实例化固定的字符串。

template<std::basic_fixed_string T>
class Foo {
    static constexpr char const* Name = T;
public:
    void hello() const;
};

int main() 
{
    Foo<"Hello!"> foo;
    foo.hello();
}

constexpr 虚函数

由于动态类型是未知的，因此无法在常量表达式中调用虚拟函数。C++20 将沿用这个限制。

指定初始化值

让我先写一个使用聚合初始化的简单例子：

// aggregateInitialisation.cpp
#include <iostream>

struct Point2D {
    int x;
    int y;
};

class Point3D {
public:
    int x;
    int y;
    int z;
};

int main()
{
    std::cout << std::endl;
   
    Point2D point2D {1, 2};
    Point3D point3D {1, 2, 3};

    std::cout << "point2D: " << point2D.x << " " << point2D.y << std::endl;
    std::cout << "point3D: " << point3D.x << " " << point3D.y << " " << point3D.z << std::endl;
    
    std::cout << std::endl;
}

我认为没有必要解释这个程序。下面是这个程序的输出:

显式胜于隐式。让我们看看这意味着什么。程序 aggregateInitialisation.cpp 中的初始化非常容易出错，因为你可能会在不经意间交换构造函数参数的顺序。下面所示的指定初始化值是从 C99 开始引入的。

// designatedInitializer.cpp
#include <iostream>

struct Point2D {
    int x;
    int y;
};

class Point3D {
public:
    int x;
    int y;
    int z;
};

int main()
{
    std::cout << std::endl;
    
    Point2D point2D {.x = 1, .y = 2};
    // Point2D point2d {.y = 2, .x = 1};         // (1) error
    Point3D point3D {.x = 1, .y = 2, .z = 2};   
    // Point3D point3D {.x = 1, .z = 2}          // (2)  {1, 0, 2}
    
    std::cout << "point2D: " << point2D.x << " " << point2D.y << std::endl;
    std::cout << "point3D: " << point3D.x << " " << point3D.y << " " << point3D.z << std::endl;
    
    std::cout << std::endl;
}

Point2D 和 Point3D 实例的参数是被显式声明的。该程序的输出与程序 aggregationInitialisation.cpp 的输出相同。注释 (1) (2) 所在的行非常有趣，行 (1) 会产生错误，因为指示符的顺序与其声明顺序不匹配。行 (2) 中 y 的指定值缺失。在这种情况下，y 将被初始化为 0，就如同使用大括号初始化列表 { 1, 0, 3 } 的效果一样。

Lambda 的各种改进

Lambda 表达式将在 C++20 中进行多项改进。
如果你想了解改进的详细信息，请转到 Bartek 的有关 C++17 和 C++20 中关于 lambda 改进的文章，或者等待我的详细文章。无论如何，我们将获得的两个有趣的变化：

• 允许 [=, this] 作为 lambda 捕获器，并弃用隐式 this 捕获器 [=]

struct Lambda {
    auto foo() {
        return [=] { std::cout << s << std::endl; };
    }

    std::string s;
};

struct LambdaCpp20 {
    auto foo() {
        return [=, this] { std::cout << s << std::endl; };
    }

    std::string s;
};

在 C++20 中，隐式 [=] 捕获器在 Lambda 结构中复制会引起一个弃用警告。当我们通过复制 [=, this] 显式捕获 this 对象时，在 C++20 中， 我们将不会在收到弃用警告。

• 模板 lambda
  对此你的第一印象可能是：我们为什么需要模板 lambda？C++14 标准中当我们写下一个泛型 lambda： [](auto x){ return x; } 时，编译器会自动生成一个带有模板化的调用操作符的类：

template <typename T>
T operator(T x) const {
    return x;
}

但有时候，你想要定义一个仅适用于特定类型(如：std::vector)的 lambda 表达式。此时，模板 lambda 能帮我们达到这个目的。除了类型参数，你还可以使用一个概念：

auto foo = []<typename T>(std::vector<T> const& vec) { 
        // do vector specific stuff
    };

新属性：[[likely]] 和 [[unlikely]]

使用 C++20，我们可以获取新的属性 [[likely]] 和 [[unlikely]] 。不管执行路径概率大小，这两个属性都允许它给优化器一个提示。

for(size_t i=0; i < v.size(); ++i) {
  if (unlikely(v[i] < 0)) sum -= sqrt(-v[i]);
  else sum += sqrt(v[i]);
}

consteval 和 constinit 说明符

新的说明符 consteval 用来创建了一个即时函数。即时函数指每次调用该函数都必须生成编译期常量表达式的函数。即时函数是隐式的 constexpr 函数。

consteval int sqr(int n) {
  return n*n;
}
constexpr int r = sqr(100);  // OK
 
int x = 100;
int r2 = sqr(x);             // Error

由于 x 不是常量表达式，因此 sqr(x) 不能在编译时执行 constinit 确保在编译时初始化具有静态存储期的变量，所以最后的赋值会出现错误。静态存储期意味着在程序开始时分配对象，在程序结束时释放对象。在命名空间范围内声明的对象(全局对象)，使用 static 或 extern 声明的对象具有静态存储期。

std::source_location

C++11 中有 __LINE__ 和 __FILE__ 两个宏用于获取相应的信息。在 C++20 中，类 source_location 能给出关于源代码的文件名、行号、列号和函数名等信息。cppreference.com 上的这个简短的例子展示了它的第一种用法：

#include <iostream>
#include <string_view>
#include <source_location>
 
void log(std::string_view message,
         const std::source_location& location = std::source_location::current())
{
    std::cout << "info: "
              << location.file_name() << " : "
              << location.line() << " "
              << message << '\n';
}
 
int main()
{
    log("Hello world!");  // info: main.cpp: 15 Hello world!
}

接下来？

这篇文章是对核心语言特性的概述。下一篇文章我们将继续讲述 C++20 中的标准库特性。