在条款1中，我们已经了解了有关模板型别的推导的一切必要知识，那么也就意味着基本上了解了auto型别推导的一切必要知识。
因为，除了一个奇妙的例外情况，auto型别推导就是模板型别推导。尽管和模板型别推导打交道的是模板、函数和形参，auto和它们秋毫无犯，但并不影响上面的结论成立。
在条款1中，我们用来解释模板型别推导的函数模板形如：
template<typename T>
void f(ParamType param);
而一次调用形如：
f(expr); //以某表达式调用f
在f的调用语句中，编译器会利用expr来推导T和ParamType的型别。
当某变量采用auto来声明时，auto就扮演了模板中的T这个角色，而变量的型别饰词则扮演的是ParamType的角色。
所以，除了一种例外情况（马上要讨论），和为模板推导型别一模一样。
条款1根据ParamType的特征，即一般形式的函数模板中param的型别饰词，将模板推导分为三种情况。而在采用auto进行变量声明中，型别饰词取代了ParamType，所以也存在三种情况：
情况1：型别饰词是指针或引用，但不是万能引用；
情况2：型别饰词是万能引用；
情况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的型别是int& auto&& uref2 = cx; //cx的型别是const int，且是左值， //所以uref2的型别是const int& auto&& uref2 = 27; //27的型别是int，且是右值， //所以uref3的型别是int&&
条款1中数组和函数名称在非引用型别饰词的前提下退化成指针，同样的结论也适用于auto型别推导：
const char name[] = "Hello World"; //name的型别是const char[12] auto arr1 = name; //arr1的型别是const char* auto& arr2 = name; //arr2的型别是const char(&)[12] void someFunc(int ,double); //someFunc是个函数， //其型别是void(int ,double)
auto func1 = someFunc; //func1的型别是void(*)(int, double) auto& func2 = someFunc; //func2的型别是void(&)(int, double)
auto型别推导和模板型别推导的运作是类似的。
下面我们讨论只有一个不同之处。我们观察一下，若要声明int，并将其初始化为值27，C++98中有两种可选语法：
int x1 = 27; int x2(27);
而C++11为了支持统一初始化，增加了下面的语法规则：
int x3 = { 27 }; int x4{ 27 };
共计四种语法，然而结果却殊途同归：得到一个值为27的int。
采用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的一条特殊的型别推导规则所致。当用于auto声明变量的初始化表达式是使用大括号括起来时，推导所得的型别就属std::initializer_list<int>。
这么一来，如果型别推到失败（例如，大括号里的值型别不一），则代码就通不过编译：
auto x5 = { 1, 2, 3.0}; //错误！
//推导不出std::initializer_list<T>中的T
正如注释所指出的那样，这种情况下型别推导会失败，但重点在于，要意识到这里发生了两种型别推导。第一种源于auto的使用：x5的型别需要推导。而x5的初始化表达式是用大括号括起的，所以x5必须推导为一个std::initializer_list。但std::initializer_list是个模板，它要根据某个型别T产生实例型别std::initializer_list<T>，而这就意味着T的型别也必须被推导出来。而后一次推导就落入了第二种型别推导，即模板型别推导的范畴了。在该例中，推导会失败，因为大括号括起的初始化表达式中的值型别不一。
对于大括号初始化表达式的处理方式，是auto型别推导和模板型别推导的唯一不同之处。当采用auto声明的变量使用大括号初始化表达式进行初始化时，推导所得的型别是std::initializer_list的一个实例型别。但是，如果想对应的模板传入一个同样的初始化表达式，型别推导就会失败，代码不能通过编译：
auto x = { 11, 23, 9 }; //x的型别是std::initializer_list<int>
template<typename T> //带有形参的模板
void f(T param); //与x的声明等价的声明式
f({ 11, 23, 9}); //错误！无法推导T的型别
所以，auto和模板型别推导真正的唯一区别在于，auto会假定用大括号括起来的初始化表达式代表一个std::initializer_list，但模板型别推导却不会。
不过，若指定模板中的param为std::initializer_list<T>，则在T的型别未知时，模板型别推导机制会推导出T应有的型别：
template<typename T> //带有形参的模板 void f(std::initializer_list<T> param); f({ 11, 23, 9}); //T的型别推导为int //从而initList的型别std::initializer_list<int>
关于C++11，上面所说的就是全部了。但是关于C++14，还有别的要说。C++14允许使用auto来说明函数返回值需要推导，而且C++14中的lambda式也会在形参声明中用到auto。然而，这些auto用法是在使用模板型别推导而非auto型别推导。所以带有auto返回值的函数若要返回一个大括号括起的初始化表达式，是通不过编译的：
auto createInitList() { return { 1, 2, 3}; //错误：无法为{ 1, 2, 3}完成型别推导 }
同样地，用auto来制定C++14中lambda式的形参型别时，也不能使用大括号括起的初始化表达式：
std::vector<int> v; ... auto resetV = [&v](const auto& newValue) { v = newValue; }; // C++14 ... resetV( {1,2,3});//错误！无法为{1,2,3}完成型别推导
要点速记：
1、在一般情况下，auto型别推导和模板型别推导时一模一样的，但是auto型别推导会假定用大括号括起的表达式代表一个std::initializer_list，但模板型别推导却不会。
2、在函数返回值或lambda式的形参中使用auto，意思是使用模板型别推导而非auto型别推导。