类型推导规则
在大多数情况下，模板与auto的类型推导规则一致，且规则很简单。
情况1. 没有加任何修饰
// 模板函数：
template <typename T>
f(T t) {...}
// auto声明：
auto x = ...;
这种情况下，参数是按值传递，形参t或者变量x都是一个副本，那么就需要去掉引用，且副本本身没必要加cv限定符（const、volatile，下文都不考虑volatile，只说const），也需要去掉。
const int& a = ...;
f(a); // T 推导为 int
auto x = a; // x 的类型为 int
但需要注意，只能去掉变量本身的const，对于指针类型，所指对象的const修饰不能去掉。
const int* const a = ...;
f(a) // T 推导为 const int*
auto x = a; // x 的类型为 const int*
其实不需要特别记忆，只要记住一点：在能编译通过的前提下，去掉没必要的const和&符号即可：
const int& a = ...;
// 以下语句能否编译通过？
const int& x = a; // OK
int& x = a; // 编译不通过，const int& 类型不可转为int&
const int x = a; // OK
int x = a; // OK，且去掉了多余的const和&符号
// 因此，auto x = a; 中，x类型推导为 int
const int* const b = ...;
// 以下语句能否编译通过？
int* const x = b; // 编译不通过
const int* const x = b; // OK
const int* x = b; // OK，且去除了多余的const
// 因此，auto x = b; 中，x类型推导为 const int*
情况2. 加了引用
也就是T&的形式:
// 模板函数：
template <typename T>
f(T& t) {...}
// auto声明：
auto& x = ...;
这种情况则需要保持原有的const，举例来看：
const int a = 1;
f(a); // T 推导为 const int，所以形参t类型为 const int&
auto& x = a; // x类型推导为 const int
保留const的原因也很好理解，因为这里是引用传递，丢掉const会导致可以修改原来的值，同样编译不通过：
const int a = 1;
int& x = a; // 编译不通过
const int& x = a; // OK
情况2.2 万能引用
如果加了两个引用符号 &&，则可以根据情况推导为普通的引用，或者右值引用，因此也叫做万能引用：
// 模板函数：
template <typename T>
f(T&& t) {...} // &&表示万能引用
// auto声明：
auto&& x = ...; // &&表示万能引用
// 举例：
int a = 1;
auto&& x = a; // x的类型是 int&
auto&& x = 1; // x的类型是 int&& 右值引用
其他情况
经过上面的分析，我们得出结论，对于模板类型的推导，其实只要能替换成普通函数，并去掉不必要的const和引用&，就可以得到推导结果。
书中特别提到了数组作为函数实参的特殊情况，但实际上这并不算什么特殊情况。我们先了解下普通函数，数组作为参数的情况。
在普通函数签名中，形参可以写成数组的形式，但实际上类型还是指针。二者最大的区别是：指针并不会包含数组长度信息。这也是为什么函数以数组作为参数时，一般还要再传入数组长度参数。
int getlen(char a[]) { // 等价于 int* a 或 int a[1]
return sizeof(a);
}
int main() {
char a[2];
cout << sizeof(a); // 输出 2 即两个char所占的空间
cout << getlen(a); // 输出 8 即int*指针所占的空间
}
其实，如果想要保留数组的长度信息，也有办法，那就是使用“数组的引用”作为函数参数：
int getlen(char (&a)[2]) { // a是数组char[2] 的引用类型
return sizeof(a); // 返回2
}
注意，形参中需指定长度，且需要与实参的数组长度一致。
而对于模板函数其实是一样的，可以使用数组作为参数，这样实际上的类型是指针；也可以使用“数组的引用”作为参数，保留长度信息。
template<typename T>
int f(T t) {
return sizeof (t);
}
template<typename T>
int g(T& t) {
return sizeof(t);
}
char a[2];
cout << f(a) << endl; // 输出 8, 即指针的长度，t被推导为char*类型
cout << g(a) << endl; // 输出 2, t被推导为 char(&)[2] 类型
auto x = a; // x类型推导为 char*
auto& y = a; // y类型推导为 char(&)[2]
仔细对比后发现，其实这和普通函数的规则完全一致，即：数组会退化为指针，数组引用则不会。
有趣的是，利用这一特性，我们可以写一个函数，获得数据长度：
template<typename T, std::size_t N>
constexpr std::size_t arraySize(T(&)[N]) {
return N;
}
char a[2];
// 声明一个与数组a长度相同的array
std::array<char, arraySize(a)> arr{};
arraySize声明中的constexpr表示：返回的N是编译期常量。这样才可以用在array的声明中。
auto与模板唯一的区别
前面的每个例子中，都同时包含了模板与auto的类型推导，它们二者的推导结果都一摸一样。二者唯一的一点不同是：auto支持初始化表达式，而模板不支持：
template<typename T>
void f(T param);
f({1,2,3}); // 错误，无法推导
auto x = {1,2,3}; // OK，x类型推导为std::initializer_list<int>
auto y = {1,2,3.0}; // 错误，包含int和double，无法推导
int[] z = {1,2,3}; // OK
在上例中，模板与auto出现区别的根本原因在于，C++11中为了支持统一初始化，可以用这种语法进行声明；而函数参数则没有这样的语法。
当然，这样推导的结果总是std::initializer_list<T>的类型，往往不是我们想要的结果，所以还是尽量去避免这样使用。
auto使用的优劣
大多数时候，优先使用auto
使用auto的好处包括：
- 简化一长串复杂的类型
- 避免忘记初始化（使用auto未初始化会产生编译错误）
- 类型变更时可以自适应
- 能够为lambda表达式声明变量，且优于std::function，不需要堆内存
- 避免由于类型写错导致额外的运行开销
关于最后一点，额外的运行开销，举例说明一下：
std::unordered_map<std::string, int> m;
// 不使用auto进行遍历，代码出现瑕疵：
for (const std::pair<std::string, int>& p : m) {
//... 对p进行操作
}
// 使用auto：
for (const auto& p : m) {
// ...
}
在for循环中，我们本意并不希望发生任何拷贝，因此使用了const引用的形式声明p，但很可惜，在代码运行中，仍然会发生拷贝。为什么呢？
原因是，m中元素正确类型是：std::pair<const std::string, int>，const不可以丢掉。由于这和代码中p的类型不匹配，编译器就会将其拷贝一份，并进行类型转换。所以，由于程序员对p类型的判断失误，导致运行期额外的性能开销。
而使用auto时，则永远会推断出正确的类型，可以完全避免这个问题。
auto使用的坑
有一种情况，使用auto无法得到我们想要的类型，这甚至可能会导致十分隐蔽的问题。例如：
std::vector<bool> GetVec() {
return {true};
}
void HandleBool(bool b) {
cout << b;
}
int main() {
auto b = GetVec()[0]; // 这里auto如果换成bool，一切正常
HandleBool(b);
}
本例中，我们将std::vector<bool>的operator[]操作结果赋值给b，期望变量b是bool类型，并在HandlerBool中进行打印。然而实际运行发现，打印的值往往不符合预期。
这是为什么？原因在于，b的类型并没有推断为bool，而是一个std::vector<bool>::reference类型的复杂对象，其中包含一个指针，指向vector<bool>中的某个位置。
之所以这样做，是因为vector内部针对bool类型做了一些优化。正常情况下，这个对象可以正确转化成bool类型。但是，在上例中，GetVec返回的vector在执行完这一行代码后已经销毁，b对象中的指针则成为野指针，在调用HandlerBool时，无法正确转化成bool类型。
在本例中，std::vector<bool>::reference类型我们称之为代理类，它可以模拟另一种类型。类似的，智能指针shared_ptr、unique_ptr也是代理类，它们可以模拟普通指针。但本例中的代理类更加隐蔽，我们难以察觉，才会出现上述问题。
所以，对于这种隐形代理类，需要根据情况避免使用auto来声明。
