现代 C++：自动类型推导
自动类型推导
现代的编程语言，不管是动态语言（JavaScript、Python 等），还是静态语言（Go、Rust 等），大都支持自动类型推导（type deduction）。
自动类型推导，通俗地讲就是定义一个变量的时候不需要明确指定类型，而是让编译器根据上下文进行推导。
在 C++11 之前，模板（template）代码就支持编译器自动类型推导。C++11 很重要的一个特性就是加强了编译器自动类型推导的能力，使之不限于模板 —— 与此相关的关键字有两个 auto 和 decltype 。
auto
我们来看看 auto 关键字在 C++ 中的使用。最简单的用法，定义变量的时候不指定类型，通过初始化的值让编译器自动推导。
auto a; // 编译不通过
auto b = 0; // b 是 int 类型
auto c = 0ull; // c 是 unsigned long long 类型
auto d = "Hello World"; // d 是 const char* 类型
auto e = std::string("Hello"); // e 是 std::string 类型
auto 和容器类型、迭代器一起配合使用，可以少打很多字，代码也更简洁、清晰。
std::vector<int> v(10, 1);
auto itr_begin = v.begin(); // std::vector<int>::iterator
auto itr_end = v.end(); // std::vector<int>::iterator
auto sz = v.size(); // std::vector<int>::size_type
如果不用自动类型推导，下面 v 的类型写起来也很麻烦。如果 b 和 e 是自定义的迭代器，不一定能用 typename std::iterator_traits<Iter>::value_type 来获得类型。
template<typename Iter>
void Process(Iter b, Iter e) {
while (b != e) {
auto v = *b; // 如果不用自动类型推导，如何获得 *b 的类型
// typename std::iterator_traits<Iter>::value_type v = *b;
std::cout << v << std::endl;
++b;
}
}
类型推导可以和 Lambda 表达式一起愉快地使用。
auto Plus = [](int a, int b) { return a + b; };
也许有人会说，Lambda 表达式可以用一个 std::function
std::function<int(int, int)> PlusFunc = [](int a, int b) { return a + b; };
但是这样做有几点不好：
std::function 内部会涉及动态内存分配，性能上劣于自动类型推导的实现； 让代码看起来复杂不少； 对于泛型 Lambda 表达式，std::function 也无能为力了。
// std::function<T> 的类型没法写了
auto Plus = [](auto a, auto b) { return a + b; };
std::cout << Plus(3, 4) << std::endl;
std::cout << Plus(3.14, 1.11) << std::endl;
std::cout << Plus(std::string("hello"), std::string("world")) << std::endl;
某些情况下，自动类型推导还可以让你避免一些“坑”。比如：
std::unordered_map<std::string, int> m;
// ...
// 你觉得有没有问题？
for (const std::pair<std::string, int>& pa : m) {
// ...
}
看得出上面这段代码有什么问题吗？
上面的代码会导致复制整个 unordered_map。因为 std::unordered_map<Key, T>::value_type 的类型是 std::pair<const Key, T>。正确的写法应该是：
for (const std::pair<const std::string, Foo>& pa : m) {
// ...
}
用自动类型推导可以简单避免这个坑：
for (const auto& pa : m) {
// ...
}
当然，用自动类型推导的时候，也可能引入一些坑。比如：
std::vector<bool> v2;
v2.push_back(true);
v2.push_back(false);
auto b2 = v2[0]; // b2 是什么类型？
因为 std::vector<bool> 的特殊实现原因，变量 b2 不是一个 bool 类型，而是一个自定义的类。（无论你是否使用自动类型推导，都尽可能不要使用 std::vector<bool>。）
decltype
decltype 的作用是，告诉你一个表达式/变量/常量是什么类型。比如：
// 输出 i，表示 int
std::cout << typeid(decltype(1)).name() << std::endl;
float f;
// 输出 f，表示 float
std::cout << typeid(decltype(f)).name() << std::endl;
unsigned a = 1;
unsigned long long b = 2;
// 输出 y，表示 unsigned long long
std::cout << typeid(decltype(a + b)).name() << std::endl;
typeid(T).name() 在不同的编译器下的输出可能不一样。本文在 Ubuntu 上使用 gcc 7.5 进行编译。
typeid(T).name() 的输出可以通过 c++filt 工具转换成实际可读的类型名称。
相比 auto，decltype 用得少很多。
举一个例子：
template<typename T, typename U>
??? Plus(T t, U u)
return t + u;
}
t + u 到底应该返回什么类型？
Plus(1, 2); // 返回值类型应该是 int
Plus(1, 2.0); // 返回值类型应该是 double
使用 decltype 的 trailing return type 来解决这个问题：
template<typename T, typename U>
auto Plus(T t, U u) -> decltype(t + u) {
return t + u;
}
C++ 14 进行了加强，可以省掉这条尾巴。
template<typename T, typename U>
auto Plus(T t, U u) {
return t + u;
}
如果函数有多个 return 语句，需要保证它们返回的类型都是一样的才能成功编译。
// error: inconsistent deduction for
// auto return type: ‘int’ and then ‘double’
auto f(int i) {
if (i == 1) {
return 1;
} else {
return 2.0;
}
}
decltype(auto)
使用 auto 需要自己手动说明是值类型还是引用类型。C++14 引入 decltype(auto) 来自动推导精确类型——其实 decltype(auto) 算是 decltype(expr) 的一个语法糖。
std::vector<std::string> v{"C++11", "C++14", "C++17"};
// v[0] 的返回值类型是 std::string&
// 但是 a 是 std::string
auto a = v[0];
// a 是 std::string&
auto& b = v[0];
// C++11，我们可以这样确定精确类型
// c 是 std::string&
// 但是，如果 v[0] 变成一个复杂的表达式，代码写出来可能很难看懂
decltype(v[0]) c = v[0];
// C++14 引入了 decltype(auto)，可以自动推导出精确类型
// d 是 std::string&
decltype(auto) d = v[0];