接口
回顾一下 Human 和 Student：
class Human { // 虚基类
public:
virtual ~Human() {}; // 不能是纯虚函数
virtual void talk() = 0; // 纯虚函数，没有函数体
};
class Student final : public Human {
public:
Student(const std::string& name) : name_(name) {}
void talk() override { // 重写父类的纯虚函数，有函数体
std::cout << fmt::format("Student {} talk.\n", name_);
}
private:
std::string name_;
};
定义了纯虚函数的类是虚基类，虚基类的作用是当成接口给其他用户使用，其他用户只关心该类提供了什么功能，而不用关心实现的细节，甚至不用关心实际类型。Human 定义了纯虚函数 talk()，它的函数体是由子类 Student 去实现的。
注意，析构函数不能是纯虚函数。这是因为子类（Student）在析构的时候会调用父类（Human）的析构函数，来销毁父类子对象。如果父类的析构函数是纯虚函数（换句话说，没有实现；再换句话说，没有函数体），那么父类就没有办法销毁了。
Dynamic_cast
虽然 Student 和 Teacher 都继承自 Human，但是它们可能各自有独特的能力。比如，Student 可以学，Teacher 可以教：
class Student final : public Human {
public:
// ...
void learn() { // Student 独特的函数
std::cout << fmt::format("Student {} learn.\n", name_);
}
// ...
};
class Teacher final : public Human {
public:
// ...
void teach() { // Teacher 独特的函数
std::cout << fmt::format("Teacher {} teach.\n", name_);
}
// ...
};
现在我们有一个函数，根据输入对象的实际类型，来调用它独特的函数：
// 根据输入的实际类型，调用不同的函数
void do_something(Human* ph) {
// 尝试将 Human 转换成 Student
if (auto ps = dynamic_cast<Student*>(ph); ps) {
ps->learn(); // 调用 Student 独特的函数
}
// 尝试将 Human 转换成 Teacher
else if (auto pt = dynamic_cast<Teacher*>(ph); pt) {
pt->teach(); // 调用 Teacher 独特的函数
}
}
Dynamic_cast() 函数用来做类型转换，如果输入对象的实际类型不是我们希望的类型，则转换失败，得到空指针；如果输入对象的实际类型是我们希望的类型，则转换成功。
统一初始化
C++11 之前对象初始化都是小括号，会带一些问题：
class Human {};
Human h(); // error
我们定义了 Human 类型，接着希望定义一个 Human 类型的对象 h。但是编译器会报错，因为编译器把对象定义当成了函数声明，函数名是h，参数是空，返回值是 Human 类型。
C++11 引入了大括号初始化，帮助编译器做出正确的选择：
class Human {};
Human h{}; // correct
如果我们想使用字符串 “abc” 来初始化一个 std::string 对象，下面 3 种写法是等价的：
std::string s1("abc"); // 小括号初始化
std::string s2 = "abc"; // 赋值初始化（隐式构造）
std::string s3{ "abc" }; // 大括号初始化
注意，我们一般使用大括号初始化，可以方便地区分变量和函数。
C++11引入了初始化列表 std::initializer_list，帮助我们更方便地完成初始化操作，它的底层实现是数组。我们可以使用初始化列表来替换上面的 “abc”：
std::initializer_list<char> il = { 'a', 'b', 'c' };
std::string s4{ il }; // 把元素 'a'，'b'，'c' 添加到容器 s4 中
我们也可以把临时的初始化列表对象当成参数：
std::string s4{ { 'a', 'b', 'c' } };
甚至可以省略外面的大括号：
std::string s5{ 'a', 'b', 'c' };
大括号即可给普通对象初始化，也可以给容器初始化，所以大括号初始化也叫做统一初始化。
注意，下面两个初始化是不一样的：
std::string s6(3, 'a'); // 添加 3 个 'a' 到容器 s6 中
std::string s7{ 3, 'a' }; // 添加 3 和 'a' 到容器 s7 中
右值语义
左值可以放在等号左边，右值可以放在等号右边：
- 左值：可以获取地址。
- 将亡值：右值引用。
- 纯右值：字面量，临时变量。
引用分为左值引用和右值引用。左值引用只能绑定到左值，右值引用只能绑定到右值。但是，常量左值引用可以绑定到右值。C++提供了 std::move() 函数，来将左值转换成右值引用。左值被转成后就不应该再使用了，因为它的资源可能已经移动走了。
右值的用处：
- 提高效率。大多数情况下，移动的效率比复制高。复制是将对象管理的资源做了一份拷贝（深拷贝），而移动则是将资源转交给了其他对象（浅拷贝）。
- 移动语义。有些类型无法将管理的资源进行拷贝，比如套接字、数据库连接。传递这种类型只能使用移动，不能使用复制。
自动类型推导
Auto 可以根据初始化的输入来推导变量的类型，先来看输入是左值的情况：
int n = 1024; // 左值
auto x1 = n; // int
auto& x2 = n; // int&
auto&& x3 = n; // int&
有 3 种形式：
- x1 的类型就是 n 的类型，与 n 的 CV 限定符无关，与 n 是左值还是右值无关。
- x2 的类型是左值引用，只能绑定到左值，并且与 n 的 CV 限定符有关。
- x3 是万能引用，类型取决于 n 是左值还是右值。如果 n 是左值，则 x3 是左值引用；如果 n 是右值，则 x3 是右值引用。由于 n 是左值，x3 是左值引用。
再来看输入是右值的情况：
auto x1 = 1024; // int
const auto& x2 = 1024; // const int&
auto&& x3 = 1024; // int&&
同样有 3 种形式：
- x1 的类型就是 1024 的类型。
- x2 的类型是常量左值引用，可以绑定到右值。注意，不能去掉 const，因为非常量左值引用只能绑定到左值。
- x3 是万能引用，由于 1024 是右值，x3 是右值引用。
字面量
Auto 可以搭配字面量使用：
auto x1 = 0; // int
auto x2 = 0u; // unsigned int
auto x3 = 0l; // long
auto x4 = 0ul; // unsigned long
auto x5 = 0.0f; // float
auto x6 = 0.0; // double
auto x7 = "abc"; // const char*
还可以表示时间：
#include <chrono>
using namespace std::literals;
auto t1 = 1s; // std::chrono::seconds
auto t2 = 1ms; // std::chrono::miniseconds
auto t3 = 1us; // std::chrono::microseconds
auto t4 = 1ns; // std::chrono::nanoseconds