[C++知识库][Effective Modern C++]条款 2：理解 auto 类型推导

• auto 类型推导通常和模板类型推导相同，但是 auto 类型推导假定花括号初始化代表 std::initializer_list ，而模板类型推导不这样做
• 在 C++14 中 auto 允许出现在函数返回值或者lambda函数形参中，但是它的工作机制是模板类型推导那一套方案，而不是 auto 类型推导

在条款 1中，模板类型推导使用下面这个函数模板：

template<typename T>
void f(ParmaType param);
f(expr);			//在 f 的调用中，编译器使用 expr 推导 T 和 ParamType 的类型。

当一个变量使用 auto 进行声明时， auto 扮演了模板中 T 的角色，变量的类型说明符扮演了 ParamType 的角色。在下面的例子中编译器需要推导 x，rx 和 cx 的类型，编译器的行为看起来就像是认为这里每个声明都有一个模板，然后使用合适的初始化表达式进行调用：

auto x = 27;				//类型说明符是auto

template<typename T>            //概念化的模板用来推导x的类型
void func_for_x(T param);
func_for_x(27);                 //param的推导类型是x的类型


const auto cx = x;			//类型说明符是const auto

template<typename T>
void func_for_cx(const T param);
func_for_cx(x);                 //param的推导类型const int是cx的类型


const auto & rx=cx;			//类型说明符const auto&

template<typename T>
void func_for_rx(const T & param);
func_for_rx(x);                 //param的推导类型const int&是rx的类型

auto 类型推导除了一个例外（我们很快就会讨论），其他情况都和模板类型推导一样。

在使用 auto 作为类型说明符的变量声明中，类型说明符代替了 ParamType ，因此条款 1 描述的三个情景稍作修改就能适用于auto：

• 情景一：类型说明符是一个指针或引用但不是通用引用
• 情景二：类型说明符一个通用引用
• 情景三：类型说明符既不是指针也不是引用

auto x = 27;                    //情景三（x既不是指针也不是引用）
const auto cx = x;              //情景三（cx也一样）
const auto & rx=cx;             //情景一（rx是非通用引用）

auto&& uref1 = x;               //x是int左值，所以uref1类型为int&
auto&& uref2 = cx;              //cx是const int左值，所以uref2类型为const int&
auto&& uref3 = 27;              //27是int右值，所以uref3类型为int&&

//对于non-reference类型说明符，数组和函数名如何退化为指针也同样适用于auto类型推导
const char name[] =             //name的类型是const char[13]
 "R. N. Briggs";

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的int，可以有以下选择：

int x1 = 27;		//C++98
int x2(27);			//C++98
//C++11添加了用于支持统一初始化（uniform initialization）的语法
int x3 = { 27 };	//C++11
int x4{ 27 };		//C++11

如果我们把上面声明中的 int 替换为 auto ：

auto x1 = 27;
auto x2(27);
auto x3 = { 27 };		//类型是std::initializer_list<int>，值是{ 27 }
auto x4{ 27 };			//类型是std::initializer_list<int>，值是{ 27 }

这些声明都能通过编译，但是后面两个的意义跟我们想象的完全不同，不是声明了一个类型 int 值为 27 的变量，而是声明了一个存储一个元素27的 std::initializer_list<int> 类型的变量。

这就是 auto 类型推导不同于模板类型推导的特殊情况：当用 auto 声明的变量使用花括号进行初始化， auto 类型推导推出的类型则为std::initializer_list。如果这样的一个类型不能被成功推导（比如花括号里面包含的是不同类型的变量），编译器会拒绝这样的代码：

auto x5 = { 1, 2, 3.0 };	//错误！无法推导std::initializer_list<T>中的T。推导之所以失败，是因为x5使用花括号的方式进行初始化，因此x5必须被推导为std::initializer_list，但是因为花括号中的值并不是同一种类型，所以推导失败

对于花括号的处理是 auto 类型推导和模板类型推导唯一不同的地方。对于模板类型推导这样就行不通：

auto x = { 11, 23, 9 };         //x的类型是std::initializer_list<int>

template<typename T>            //带有与x的声明等价的
void f(T param);                //形参声明的模板

f({ 11, 23, 9 });               //错误！不能推导出T

//然而如果在模板中指定T是std::initializer_list<T>而留下未知T,模板类型推导就能正常工作：
template<typename T>
void f(std::initializer_list<T> initList);

f({ 11, 23, 9 });               //T被推导为int，initList的类型为std::initializer_list<int>

C++14允许 auto 用于函数返回值并会被推导，而且C++14的lambda函数也允许在形参声明中使用 auto 。但是在这些情况下 auto 实际上使用模板类型推导的那一套规则在工作，而不是 auto 类型推导，所以说下面这样的代码不会通过编译：

auto createInitList()
{
    return { 1, 2, 3 };         //错误！不能推导{ 1, 2, 3 }的类型
}

std::vector<int> v;
…
auto resetV = 
    [&v](const auto& newValue){ v = newValue; };        //C++14
…
resetV({ 1, 2, 3 });            //错误！不能推导{ 1, 2, 3 }的类型

Effective Modern C++ 中文版