介绍

这是《现代C++语言核心特性解析》的读书笔记。

constexpr家族的内容

书里给constexpr给了很多篇幅，但是总体来说就是一个，const表示的是不允许修改的常量，而constexpr表示的是编译期的常量。
但是逐渐被扩展到constexpr可以被用作函数，lambda，以及if constexprt，都是为了让编译期可以做更多的事情，给与开发者更多的自主性。
反正基本上想要去做一些预计算以及在模板里，用constexpr就没错了。

consteval是什么呢？

这件事情我理解来说就是constexpr被扩展定义之后的一个收缩，constexpr最初是为了定义编译期的常量，好让编译器在编译器做一些逻辑。但是逐渐扩展到函数也能放，同时运行期也能调用constexpr的函数。
那consteval做的事情就是，定义一个函数，这个函数只允许编译期运行。

说实话，有点过渡定义……

constinit的构造

因为之前做一个东西遇到过类似的依赖问题，后来用了宏+一个很取巧的类构造的方式来保证顺序。
然后C++20提供了一个更简单的方法，constinit保证在编译期就会初始化对象，相当于是最早初始化的一批对象。

1. 编译期的计算都可以在编译期算好，就不会有启动的依赖关系；
2. 可以被其他的非constinit对象依赖。

is_constant_evaluated

新标准还提供了一个新函数，用于区分当前逻辑运行在编译期还是运行时，可以用if constexpr去做不同的逻辑。

#include <cmath>
#include <type_traits>
constexpr double power(double b, int x) {
  if (std::is_constant_evaluated() && x >= 0) {
    double r = 1.0, p = b;
    unsigned u = (unsigned)x;
    while (u != 0) {
      if (u & 1) r *= p;
      u /= 2;
      p *= p;
    }
    return r;
  } else {
    return std::pow(b, (double)x);
  }
}

int main() 
{
  constexpr double kilo = power(10.0, 3);  // 常量求值
  int n = 3;
  double mucho = power(10.0, n);           // 非常量求值
  return 0;
}

结构化绑定

在python中是能够很轻易地实现多个返回值的函数的，例如：

def return_multi_values():
  return 100, 20
x, y = return_multi_values()

但是在C++应该是会用类、结构体或者引用来实现，在C++11之后也引入了std::tuple，也可以用来实现类似的功能：

#include <iostream>
#include <tuple>

std::tuple<int, int> return_multiple_values()
{
  return std::make_tuple(11, 7);
}

int main()
{
  int x = 0, y = 0;
  std::tie(x, y) = return_multiple_values();
  std::cout << "x=" << x << " y=" << y << std::endl;
}

这里定义和获取都很麻烦：

1. 定义的时候需要显示指定返回类型；
2. 同时在用std::tie解邦定前需要先声明x, y的变量。
   第一个问题可以通过auto来实现：

   auto return_multiple_values()
   {
   return std::make_tuple(11, 7);
   }

   第二个问题就需要使用C++17引入的新特性——结构化绑定。

所谓结构化绑定是指将一个或多个名称绑定到初始化对象中的一个或多个子对象（或者元素）上，相当于给初始化对象的子对象起了别名。这里引用和别名是有区别的。
使用结构化绑定的方式是 auto[xx, yy, zz] = xxxx，例如：

#include <iostream>
#include <tuple>

auto return_multiple_values()
{
  return std::make_tuple(11, 7);
}

int main()
{
  auto[x, y] = return_multiple_values();
  std::cout << "x=" << x << " y=" << y << std::endl;
}

但右边的值也不一定非得是函数返回值或者tuple，合理的表达式也行：

#include <iostream>
#include <string>

struct BindTest {
  int a = 42;
  std::string b = "hello structured binding";
};

int main()
{
  BindTest bt;
  auto[x, y] = bt;
  std::cout << "x=" << x << " y=" << y << std::endl;
}

在for循环里会有更好的效果：

#include <iostream>
#include <string>
#include <vector>

struct BindTest {
  int a = 42;
  std::string b = "hello structured binding";
};

int main()
{
  std::vector<BindTest> bt{ {11, "hello"},  {7, "c++"},  {42, "world"} };
  for (const auto& [x, y] : bt) {
       std::cout << "x=" << x << " y=" << y << std::endl;
  }
}

深入理解

这两个理解是错误的：

1. 结构化绑定的目标就是等号右边的对象
2. 所谓的别名就是对等号右边对象的子对象或者元素的引用。

在结构化绑定中编译器会根据限定符生成一个等号右边对象的匿名副本，而绑定的对象正是这个副本而非原对象本身。
auto [xx, yy, zz]是能够增加修饰符的，例如const，volatile等, 甚至&引用也可以，这些都会直接作用在新的变量上。

结构化绑定3种类型

包括原生数组、结构体和类对象、元组和类元组的对象。

绑定原生数组

它是所有情况中最简单的，条件是别名数量和数组数量一致。

绑定到结构体和类对象

首先，类或者结构体中的非静态数据成员个数必须和标识符列表中的别名的个数相同；其次，这些数据成员必须是公有的（C++20标准修改了此项规则，详情见20.5节）；这些数据成员必须是在同一个类或者基类中；最后，绑定的类和结构体中不能存在匿名联合体

绑定到元祖和类元祖对象

类元祖对象的定义比较复杂，不像python有ABC这种元类，C++是通过模板实现判断，目标类型提供std::tuple_size、std::tuple_element以及get的特化或者偏特化版本即算是类元祖对象。

在标准库中，除了std::tuple，还有std::pair和std::array也满足这个条件，这就带来了一个很好的特性：能够在for循环遍历map的时候直接使用结构化绑定，例如：

#include <iostream>
#include <string>
#include <map>

int main()
{
  std::map<int, std::string> id2str{ {1, "hello"}, {3, "Structured"}, {5, "bindings"} };

  for (const auto& elem : id2str) {
       std::cout << "id=" << elem.first
            << ", str=" << elem.second << std::endl;
  }
}

End.

重写、重载和隐藏

重写（override）、重载（overload）和隐藏（overwrite）在C++完全不同的概念，先梳理一下区别：

重写

重写的意思更加接近于覆盖，在C++中是指派生类覆盖了基类的虚函数，这里的覆盖必须满足有相同的函数签名和返回类型，即重写是有相同的函数名、形参列表以及返回类型。

重载

它通常指一个类中有两个或者以上的函数，他们函数名相同，但是函数签名不同。

隐藏

隐藏的概念是指基类成员函数，无论是否是虚函数，当派生类出现同名函数时，如果派生类函数签名和基类不同，则基类的会被隐藏；如果派生类函数签名和基类相同，如果是虚函数则为重写，否则为隐藏。

如果想在子类中使用基类的函数，可以使用using关键字将其引入派生类。

override: 重写的问题

重写容易出现问题，即基类定义了虚函数，但是子类的函数名写错了，也不会有编译错误，只有运行测试时才会发现错误。

因此C++引入了一个非常实用的关键字，即override，这个关键词告诉编译器，这个函数需要覆盖基类的虚函数，一旦编译器发现虚函数不符合重写规则，就会报错。

final说明符

在C++引入了final关键词来阻止派生类继承虚函数。它告诉编译器，这个函数不能被重写，如果重写了会编译报错，跟override一样放在函数声明的尾部。

End.

强枚举类型

原来继承自C语言的枚举类型在C++之父看来是一个奇怪且半生不熟的概念。

枚举的弊端

虽然枚举类型可以避免A类型赋值给B类型，但是：

• 可以直接跨枚举比较
• 可以直接转化为int
• 同名的枚举值是冲突的

虽然有很多缺点，但依然是建议使用枚举而不是const int来做枚举，那样问题只会更多。

强枚举类型

C++11标准增加了强枚举类型，为了保证老代码的兼容性，同时也兼容了旧的特性，新增的枚举类型具有三个特性：

• 枚举标识符属于强枚举类型的作用域。
• 枚举标识符不会隐式转换为整型。
• 能指定强枚举类型的底层类型，底层类型默认为int类型。
  基本上就是让枚举不是一个int的别名，而是一个独立的完全定义，具备完全语义的类型，同时解决了枚举值作用域的问题。

为了兼容旧的逻辑，所以使用了新的标识符，从enum替换成了enum class。

列表初始化有底层类型枚举对象

这一段真的很难理解，为什么C++标准要搞这种东西，即使书里面有一些解释，我还是觉得不太理解…
首先强枚举类型支持由int作为参数的列表初始化：

enum class Color {
 Red,
 Green,
 Blue
};
int main()
{
 Color c{5};
 Color c1 = 5;
 Color c2 = {5};
 Color c3(5);
};

这个例子真的震惊到我，Color的范围不是[0~2]吗，怎么就能赋值成5？
而且{5}和(5)的差别是列表初始化构造函数和参数构造函数，为什么要有这种奇怪的特性？C++真的越来越折磨人。。。
说是为了定义一种特殊的整数类型，同时这个整数类型不能跟其他的整数互相转换，强枚举类型符合这个特性，所以通过列表初始化构造函数让强枚举类型变成了一种非通用整数类型的整数类型。
C++真的越来越折磨人。。。

用using打开强枚举类型

可以使用using namesapce;的方式，省略掉强枚举类型的前缀，直接在上下文使用枚举值。

enum class Color {
 Red,
 Green,
 Blue
}
const char* ColorToString(Color c)
{
 switch(c)
 {
  case Color::Red: return"Red";
  case Color::Green: return"Green”
  case Color::Blue: return"Blue";
  default:
    return"none";
  }
}

可以改成：

enum class Color {
 Red,
 Green,
 Blue
}
const char* ColorToString(Color c)
{
 switch(c)
 {
  using Color;
  case Red: return"Red";
  case Green: return"Green”
  case Blue: return"Blue";
  default:
    return"none";
  }
}

End.