条款2 明白auto类型推导
如果你已经读完了条款1中有关模板类型推导的内容，那么你几乎已经知道了所有关于auto类型推导的事情，因为除了一个古怪的例外，auto的类型推导规则和模板的类型推导规则是一样的，但是为什么会这样呢？模板的类型推导涉及了模板，函数和参数，但是auto的类型推导却没有涉及其中的任何一个。
这确实是对的，但这无关紧要，在auto类型推导和template之间存在一个直接的映射，可以逐字逐句的将一个转化为另外一个。
在条款1中，模板类型推导是以下面的模板形式进行举例讲解的：
template<typename T> void f(ParamType param);
函数调用是这样
f(expr); //用一些表达式调用函数f
在f的函数调用中，编译器使用expr来推导T和ParamType的类型。
当一个变量用auto进行声明的时候，auto扮演了模板中的T的角色，变量的类型说明符(The type specifier)相当于ParamType，这个用一个例子来解释会更容易一些，考虑下面的例子：
auto x=27;
这里x的类型说明符就是auto本身，在另一方面，在下面这个声明中：
const auto cx=x;
类型说明符是const auto。
const auto& rx=x;
类型说明符是const auto&,在上面的例子中，为了推导x,cx,rx的类型，编译器会假装每一个声明是一个模板，并且用相应的初始化表达式来调用（compilers act as if there were a template for each declaration as well as a call to that template with the corresponding initializing expression:）
template<typename T> // 产生概念上的模板来
void func_for_x(T param); // 推导x的类型
func_for_x(27); // 概念上的函数调用，参数
// 推导出的类型就是x的类型
template<typename T> // 产生概念上的模板来
void func_for_cx(const T param); // 推导cx的类型
func_for_cx(x); // 概念上的函数调用，参数
// 推导出的类型就是cx的类型
template<typename T> // 产生概念上的模板来
void func_for_rx(const T& param); // 推导cx的类型
func_for_rx(x); // 概念上的函数调用，参数
// 推导出的类型就是rx的类型
就像我说的那样，auto的类型推导和模板的类型推导是一样的。
条款1把模板的类型推导按照ParamType的类型，分成了3种情况，同样，在auto声明的变量中，变量的类型说明符(The type specifier)相当于ParamType,所以auto类型推导也有3种情况:
- 情况1：类型说明符是一个指针或是一个引用，但不是一个万能引用(universal reference)
- 情况2：类型说明符是一个万能引用(universal reference)
- 情况3：类型说明符既不是指针也不是引用
我们在上面已经举过了情况1和情况3的例子
auto x = 27; //条款3(x既不是指针也不是引用) const auto cx = x; //条款3(cx既不是指针也不是引用) const auto& rx = x; //条款1(rx不是一个万能引用)
情况2也像你想的那样
auto&& uref1 = x; // x的类型是int并且是一个左值
// 所以uref1的类型是
auto&& uref2 = cx; // cx的类型是const int并且是一个左值
// 所以uref2的类型是const int&
auto&& uref3 = 27; // 27的类型是int并且是一个右值
// 所以uref3的类型是int&&
条款1同样也讨论了数组和函数名在非引用类型的类型说明符下，会退化为指针类型，这当然同样适用于auto的类型推导
const char name[] = "R. N. Briggs"; //name的类型是const char[13] name‘s type is const char[13]
auto arr1 = name; //arr1的类型是const char*
auto& arr2 = name; //arr2的类型是
// const char (&)[13]
void someFunc(int, double); //someFunc是一个函数;
//类型是void(int, double)
auto func1 = someFunc; // func1的类型是
// void (*)(int, double)
auto& func2 = someFunc; // func2的类型是
// void (&)(int, double)
就像你看到的那样，auto类型推导其实和模板类型推导是一样的，他们就相当于硬币的正反两个面。
但是在一点上，他们是不同的，如果你想把一个声明一个变量，它的初始值是27，C++98中，你可以使用下面的两种语法
int x1 = 27; int x2(27);
在C++11中，提供对统一的集合初始化(uniform initialization)的支持，增加下面是声明方式。
int x3 = {27};
int x4{27};
总而言之，上面的4种声明方式的结果是一样的，声明了一个变量，它的初始值是27。
但是就像条款5解释的那样，使用auto声明变量要比使用确定的类型声明更有优势，所以将上面代码变量声明中的int替换成auto会是非常好的，直接的文本上的替换产生了下面的代码：
auto x1 = 27;
auto x2(27);
auto x3 = {27};
auto x4{27};
这些声明都能够通过编译，但他们并非全和替代前有着同样的意义，前两个的确声明了一个int类型的变量，初始值为27；然而，后两个声明了一个std::initializer_list<int>类型的变量，它包括一个元素，初始值是27；
auto x1 = 27; // 类型是int，初始值是27
auto x2(27); // 同上
auto x3 = {27}; //类型是std::initializer_list<int>
//初始值是27
auto x4{27}; //同上
这是由于auto类型推导的一个特殊的规则，当变量使用大括号的初始化式(braced initializer)初始化的时候，被推导出的类型是std::initializer_list，如果这个类型不能被推导出来（比如，大括号的初始化式中的元素有着不同的类型），代码将不能通过。
auto x5 = {1, 2, 3.0}; // 错误！无法推导出std::initializer_list<T>中T的类型
就像注释里指出的的那样，类型推导在这种情况下失败了，但是，重要的是认识到这里其实发生了两种形式的类型推导，一种来源于auto的使用，x5的类型需要被推导出来，另外因为auto是用大括号的初始化式初始化的，x5的类型必须被推导为std::initializer_list,但是std::initializer_list是一个模板，所以实例化模板std::initizalizer_list<T>意味着T的类型必须被推导出来，在上面的例子中，模板的类型推导失败了，因为大括号里变量类型不是一致的。
对待大括号的初始化式(braced initializer)的不同是auto类型推导和模板类型推导的唯一区别，当auto变量用一个大括号的初始化式(braced initializer)初始化的时候，推导出的类型是实例化后的std::initializer_list模板的类型，而模板类型推导面对大括号的初始化式(braced initializer)时，代码将不会通过（这是由于完美转发perfect forwarding的结果,将在条款32中进行讲解）
你可能会猜想为什么auto类型推导对于大括号的初始化式(braced initializer)有着特殊的规则，而模板类型推导确没有，我也想知道，不幸的是，我没有找到一个吸引人的解释，但是规则就是规则，这意味着，你必须记住如果你用auto声明一个变量，并且用大括号的初始化式进行初始化的时候，推导出的类型总是std::initializer_list,如果你想更深入的使用统一的集合初始化时，你就更要牢记这一点，(It’s especially important to bear this in mind if you embrace the philosophy of uniform initialization of enclosing initializing values in braces as a matter of course.)C++11的一个最经典的错误就是程序员意外的声明了一个std::initializer_list类型的变量，但他们的本意却是想声明一个其他类型的变量。让我再重申一下：
auto x1 = 27; // x1和 x2都是int类型
auto x2(27);
auto x3 = {27}; // x3和x4是
auto x4{27}; // std::initializer_list<int>类型
陷阱的主要原因是一些程序员只有当必要的时候，才使用大括号的初始化式进行初始化）（This pitfall is one of the reasons some developers put braces around their initializers only when they have to. (什么时候你必须时候将在条款7中讨论）
对于C++11，这已经是一个完整的故事了，但是对于C++14，故事还没有结束，C++14允许auto来指出一个函数的返回类型需要被推导出来(见条款3),C++14的lambda表达式可能需要在参数的声明时使用auto，不管怎样，这些auto的使用，采用的是模板类型推导的规则，而不是auto类型推导规则，这意味着，大括号的初始化式会造成类型推导的失败，所以一个带有auto返回类型的函数如果返回一个大括号的初始化式将不会通过编译。
auto createInitList()
{
return { 1, 2, 3 }; // 错误: 无法推导出
} // { 1, 2, 3 }的类型
同样,规则也适用于当auto用于C++14的lambda（产生一个通用的lambda(generic lambda))的参数类型说明符时,
std::vector v;
auto resetV =
[&v](const auto& newValue) { v = newValue; }; //只在C++14下允许
…
resetV( { 1, 2, 3 } ); //错误! 无法推导出
//{ 1, 2, 3 }的类型
最终结果是auto类型推导和模板类型推导是完全相同的，除非（1）一个变量被声明了，（2）它的初始化是用大括号的初始化式进行初始化的（its initializer is inside braces），只有这种情况下，auto下被推导为std::initializer_list,而模板会失败。
请记住：
- auto的类型推导通常和模板类型推导完全相同。
- 唯一的例外是，当变量用auto声明，并且使用大括号的初始化式初始化时，auto被推导为std::initializer_list。
- 模板类型推导在面对大括号的初始化式(braced initializer)初始化时会失败。