条款2： 理解auto自己主动类型推导

假设你已经读过条款1关于模板类型推导的内容，那么你差点儿已经知道了关于auto类型推导的所有。

至于为什么auto类型推导就是模板类型推导仅仅有一个地方感到好奇。那是什么呢？即模板类型推导包含了模板、函数和參数，而auto类型判断不用与这些打交道。

这当然是真的。可是没关系。

模板类型推导和auto自己主动类型推导是直接匹配的。

从字面上看，就是从一个算法转换到还有一个算法而已。

在条款1中。阐述模板类型推导採用的是常规的函数模板：

template<typename T>

void f(ParamType param);

而且是常规方法进行调用：

f(expr);    //call f with some expression

在调用f的过程中。编译器通过expr推导出T和ParamType的类型。

当使用auto关键字声明一个变量时。auto关键字就扮演者上述模板中T的角色，而且类型说明符与ParamType扮演者相同的角色。比语言描写叙述更加清晰的是展示他们。所以请看这种样例：

auto x = 27;

这样，x的类型说明符与自己一样。

还有一方面，这样声明：

const auto cx = x;

这里的类型说明符是const auto。而这里：

const auto& rx = x;

此时类型说明符是const auto&。为了判断上面这些样例中的x，cx和rx变量，编译器起到的作用就是为每一个声明提供一个模板，而且使用对应的初始化表达式来调用这些模板：

template<typename T>        //conceptual template for deducing x's type

void func_for_x(T param);   

func_for_x(27);             //conceptual call: param's deduced type is x's type

template<typename T>        //conceptual template for deducing cx's type

void func_for_cx(const T param);   

func_for_cx(x);             //conceptual call: param's deduced type is cx's type

template<typename T>        //conceptual template for deducing rx's type

void func_for_rx(const T& param);   

func_for_rx(x);             //conceptual call: param's deduced type is rx's type

正如我之前所说，auto类型推导与模板类型推导是一样的。

条款1中依据ParamType和在常规模板中param的类型说明符，把模板类型推导分为三种情况。

在通过auto进行变量类型推导时。类型说明符替代了ParamType，但也是分为三个情况：

•第一种情况：类型说明符是一个指针或是引用，但不是universal reference。

•另外一种情况：类型说明符是一个universal reference。

•第三种情况：类型说明符既不是指针也不是引用。

我们分别看看第一和第三种情况的样例：

auto x = 27;           //case 3 (x is neither ptr nor reference)

const auto cx = x;     //case 3 (cx isn't either)

const auto& rx = x;    //case 1 (rx is non-universal ref.)

另外一种情况正如你期待的那样：

auto&& uref1 = x;       //x is int and lvalue, so uref1's type is int&

auto&& uref2 = cx;      //cx is const int and lvalue, so uref2's type is const int&

auto&& uref3 = 27;      //27 is int and rvalue, so uref3's type is int&&

条款1中总结了对于非引用类型的说明符，数组和函数名怎样退化为指针。这当然相同适用于auto类型推导：

const char name[] = "R. N. Briggs";  //name's type is const char[13]

auto arr1 = name;                    //arr1's type is const char*

auto& arr2 = name;                   //arr2's type is const char (&)[13]

void someFunc(int, double);       //someFunc is a function; type is void(int, double)

auto func1 = someFunc;              //func1's type is void(*)(int, double)

auto& func2 = someFunc;             //func2's type is void(&)(int, double)

正如您所见，auto类型推导真的和模板类型推导是一样的。

就好比一枚硬币的两个面相同。

您肯定期待二者的不同。让我从观察声明一个变量并初始化为27開始，在C++98中。给了你两种语法选择：

int x1 = 27;

int x2(27);

C++11中还添加了这个：

int x3 = {27};

int x4{27};

总之。四种语法都得到了一个结果。就是把变量初始化为27。

可是正如条款5解释的那样。使用auto取代固定的类型来声明变量有非常多的优势，所以使用auto关键字取代上面程序中的int类型。简单的文本替换我们就得到这种代码：

auto x1 = 27;

auto x2(27);

auto x3 = {27};

auto x4{27};

上面的这些都能够通过编译。可是与之前的相比，代表的含义已经不同了。上面四个表达式中前两个实际上是声明一个值为27int类型的变量。而后两个，是声明一个类型为std::initializer_list<int>，而且具有一个值为27的元素！

auto x1 = 27;        //type is int, value is 27

auto x2(27);         //同上

auto x3 = {27};      //type is std::initializer_list<int>, value is {27}

auto x4{27};         //同上

这是由于auto类型推导有特俗的规则。当为auto声明的类型进行初始化使用封闭的大括号时，则推导的类型为std::initializer_list。

假设这种类型不能被推导。这种编码是被编译器拒绝的：

auto x5 = {1, 2, 3.0}; //error! can't deduce T for std::initializer_list<T>

正如上面凝视中提示的那样，这种情况下类型推导会失败。但更重要的是认清此时採用了两种类型推导。一个是通过auto完毕对x5的类型推导。由于x5是使用大括号进行的初始化，所以x5必须被推导为std::initializer_list类型。可是std::initializer_list是一个模板。对于std::initializer_list<int>

的实例化须要推导T的类型。

这种类型推导发生另外一种类型推导的管辖范围：模板类型推导。

在这个样例中，类型推导失败，由于初始化值不具有单一类型。

对待使用大括号进行初始化，auto类型推导和模板类型推导是有差别的。当一个auto变量被大括号进行初始化时，推导的类型为std::initializer_list实例化的类型。假设一个模板面临着对于大括号初始化进行类型推导，这种代码是被拒绝的。(条款32将解释完美的转发)

你会怀疑为什么对于大括号进行初始化。auto类型推导会有特殊的规则呢，而模板类型推导则没有。我自己对此也表示怀疑。不幸的是，我找不到令人信服的解释。

可是规则就是规则，这也就意味着对于auto推导用大括号初始化的变量时你必须铭记于心，推导类型的总是std::initializer_list。这是特别重要的是要牢记这一点，假设你面对在大括号包围初始化值作为理所当然的初始化的理念。

在C++11编程中。当中最典型的错误是你想声明一个其它类型的变量，却声明一个std :: initializer_list变量。重申一下：

auto x1 = 27;    //x1 and x2 are ints

auto x2(27);

auto x3 = {27};  //x3 and x4 are std::initializer_list<int>s

auto x4{27};

这个陷阱使得一些开发人员仅仅有迫不得已的时候才使用大括号初始化变量。(我们在条款7中再讨论。)

对于C++11来说。这里是所有的内容，可是对于C++14，故事还在继续。C++14同意使用auto去推导函数的返回值(參见条款3)。而且C++14中的lambda表达式在參数声明时能够使用auto类型推导。可是，这里使用的auto推导採用的是模板推导的规则，而不是auto类型推导的规则。

这就意味着，使用大括号初始化将造成类型推导失败。所以使用auto作为返回类型的函数返回一个使用大括号初始化的变量编译不会通过：

auto createInitList()

{

    return {1, 2, 3}; //error: can't deduce type for {1, 2, 3}

}

相同的道理也适用于C++14中lambda表达式使用auto作为參数(因此产生一个通用lambda表达式)：

std::vector v;

....

auto resetV = [&v](const auto& newValue) { v = newValue;};//C++14 only

....

resetV({1, 2, 3});            //error! can't deduce type for {1, 2, 3}

终于的结果是，假设不使用大括号进行初始化。auto类型推导是和模板类型推导一致的。仅在这种情况下(使用大括号进行初始化)。auto推导为一个std:: initializer_list，但模板类型推导会失败。

请记住：

•auto类型对象通常与模板类型推导是相同的。

•唯一的例外是：使用auto和大括号进行初始化时，自己主动推导为std::initializer_lists。

•对于使用括号进行初始化，模板类型推导会失败。