现代C++之理解auto类型推断（转）

理解auto类型推断

上一篇帖子中讲述了模板类型推断，我们知道auto的实现原理是基于模板类型推断的，回顾一下模板类型推断：

template <typename T>
void f(ParamType param);

使用下面的函数调用：

f(expr);

我们看到模板类型推断过程涉及到了模板template、函数f以及参数(包括模板参数和函数参数)，调用f的时候，编译器会推断T和ParamType的类型。auto的实现和这三个部分是有着对应关系的。当使用auto声明一个变量，auto关键字扮演的是模板类型推断中T的角色,而类型说明符扮演的是ParamType的角色。看下面的例子：

auto x = 27;  //类型说明符就是auto自己
const auto cx =x; //类型说明符为const auto
const auto& rx =x;//类型说明符为const auto&

编译器使用auto对上面的类型进行推断就如同使用了下面的模板类型推断：

template<typename T> 
void func_for_x(T param); //ParamType即非引用也非指针
func_for_x(27); // 推断x的类型，T为int ,ParamType 为 int

template<typename T> 
void func_for_cx(const T param); //ParamType即非引用也非指针
func_for_cx(x); //用于推断cx的类型,T为int，ParamType为 const int

template<typename T> 
void func_for_rx(const T& param);//ParamType为引用
func_for_rx(x); // 用于推断rx的类型,T为int,ParamType为const int&

继续回顾上一篇帖子的内容，基于ParamType的三种形式，模板类型推断也对应着三种不同情况。而auto的类型说明符扮演的是ParamType，因此使用auto进行变量声明，也会有三种情况：

• 类型说明符是指针或者引用类型，但不是universal reference
• 类型说明符是universal reference。
• 类型说明符即非指针也非引用。

上面举的例子是第一种和第三种情况：

auto x = 27; //case 3 x类型被推断为int
const auto cx = x; //case 3  cx被推断为 const int
const auto &rx = x; //case 1 rx被推断为const int &

举一个情况2的例子：

auto&& uref1 = x; //x为左值，uref1被推断为左值引用
auto&& uref2 = cx; // cx  const int 左值，uref2被推断为const int &
auto&& uref3 = 27; // 27 为 int 右值，uref3被推断为 int &&

上篇帖子介绍了对于模板中的非引用ParamType,传入函数或者数组实参的时候会退化为指针的情况（而使用引用ParamType的时候，数组实参会被推断为指向数组的引用），auto类型推断也会如此：

const char name[] =  "R. N. Briggs";
auto arr1 = name; // arr1 的类型为const char*
auto& arr2 = name; // arr2 的类型为const char (&)[13]
void someFunc(int, double); 
auto func1 = someFunc; // func1的 类型为 void (*)(int, double)
auto& func2 = someFunc; // func2的类型为 void (&)(int, double)

上面介绍的都是auto和模板类型推断使用原理相同的部分，下面说的不一样的。

C++98中初始化一个Int有两种方式：

int x1=27;
int x1(27);

在C++11中，支持统一初始化（uniform initialization）:

int x3 = {27};
int x3{27};

四种语法形式的结果只有一个，初始化一个Int值为27。这里我们将都使用auto进行初始化：

auto x1 = 27;
 auto x2(27);
 auto x3 = {27};
 auto x4{27}; 

上面的四句话都能编译通过，但并没有和原来的四种形式意义完全一致。前面两个是一样的，后面两句话声明的变量类型是std::initializer_list,其中包含了单个元素，值为27。

 auto x1 = 27; //x1为int，值为27
 auto x2(27);//同上
 auto x3 = {27};//x3为 std::initializer_list<int>,值为{27}
 auto x4{27}; //同上

这里就用到了一个对于auto的特殊类型推断规则：当用大括号括起来的值对auto变量进行初始化的时候（叫做统一初始化式），变量类型会被推断为 std::initializer_list。如果不能够推断成此类型（比如，大括号中的值不是同一类型），编译会出错：

auto x5 = { 1, 2, 3.0 }; // error! 类型不一致，不能将推断为std::initializer_list<T>

这里会发生两种类型推断，一种是将统一初始化式推断为std::initializer_list ，而std::initializer_list本身也是一个类型为T的模板，因此会根据统一初始化式中的实参对T进行模板类型推断，这是第二种类型推断。上面的类型推断会失败是因为第二种类型推断会失败。

对统一初始化式的处理的不一致是auto和模板类型推断的唯一区别。使用统一初始化式对auto变量初始化会将其推断为std::initializer_list，但是模板类型推断不会这么做：

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

template<typename T> // 和auto x等同的模板类型推断
void f(T param); 

f({ 11, 23, 9 }); // 错误！这里不能推断T的类型。

如果要达到auto的效果，得按照下面的方式来做：

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

在C++11中使用auto时，这里比较容易出错，你本来想声明别的变量，最终却将其声明成了一个 std::initializer_list。因此，要谨慎使用统一初始化。

在C++14中，允许将auto作为函数返回值，也可以用其修饰lambda表达式中的参数。但是这些auto使用的都是模板类型推断，而不是auto类型推断，因此一个函数返回值为auto 类型时，返回统一初始化式的值会出错：

auto createInitList()
{
    return { 1, 2, 3 }; // 错误！不能推断{1，2，3}
}

下面的方式是对的：

std::initializer_list<int> createInitList()
{
    return { 1, 2, 3 }; // 
}

最后总结一下：

• 模板类型推断是auto的基础，auto关键字扮演了模板类型推断中的T，而类型说明符扮演的是ParamType。
• 对于模板类型推断和auto类型推断，大多数场景下推断规则相通，有一种特殊情况，就是统一初始化式。
• C++14中使用auto可以作为函数返回值，也可以作为lambda表达式的参数修饰符，但需要注意，这里的auto使用的是模板类型推断，而不是auto类型推断。

转自：https://www.cnblogs.com/harlanc/p/10628321.html