所谓型别推导，指的是我们在为变量赋予类型时不必再显式声明，编译器可以根据代码来自动推导类型。C++11中有两种型别推导的场景：模板和auto。下面我们来一一解析。
模板的型别推导
模板在C++中的应用可以参考我的这篇文章：https://www.cnblogs.com/wickedpriest/p/6123113.html。
在这里我们为了简化问题，我们定义进行模板型别推导的形式为：
template<typename **T**>
void f(**ParamType** parm);
调用的时候的格式为:
f(**expr**);
这是一个标准的函数模板，类模板以及其他形式都可以参考这个。
在编译期，编译器会根据expr来推导T和ParamType的型别。需要注意的是，T和ParamType的型别有可能是不一样的：例如T是int，而ParamType是const int&。T型别的推导结果，不仅依赖于expr，也依赖于ParamType，具体来说分为三种情况：
一、ParamType是个指针或引用，但不是个万能引用
这种情况是最简单的，型别推导会这么运作：
1.若expr具有引用型别，先将引用部分忽略
2.对expr的型别和ParamType的型别执行模式匹配，来决定T的型别
举个例子，我们的模式如下：
template<typename T>
void f(T& param);
声明变量如下：
int x = 27; // x的型别为int
const int cx = x; // cx的型别为 const int
const int &rx = x; // rx的型别为const int &
那么以下调用的型别推导为：
f(x); //T的型别是int，param的型别是int &
f(cx); //T的型别是cosnt int，param的型别是const int&
f(rx); //T的型别是const int，param的型别是const int&
请注意对rx的推导，如前面所说，expr的型别为const int&，ParamType又是引用，那么进行型别推导时首先会忽略掉expr的引用部分，然后再根据T和ParamType进行推导。
上面显示的都是左值引用形参，如果形参是右值引用也是一样的。
二、ParamType是个万能引用
关于万能应用的解析会在之后的文章中讲解，在这里我们先给出万能引用的形式：
template<typename T>
void f(T&& param);
在这种形式下，型别推导规则如下：
1.如果expr是个左值，T和ParamType都会被推导为左值引用（没错你没看错，虽然ParamType是个右值引用，但最终确实是被推导为了左值引用）。
2.如果expr是个右值，则应用上面情况一中的规则。
再次举个例子：
int x = 27;
const int cx = x;
cosnt int rx& =x;
f(x); //x是个左值，因此T和ParamType的型别为int&
f(cx); //x是个左值，因此T和ParamType的型别为const int&
f(rx); //rx是个左值，因此T和ParamType的型别为const int&
f(27); //27是个右值，因此T的型别为int，ParamType的型别为int&&
关于为什么会这样，我会在之后介绍万能引用的文章中予以说明。
三、ParamType既不是指针也不是引用
这种情况也非常简单，那就是完全地按值传递了，const和引用都会被省略掉：
template<typename T>
void f(T param);
f(x); //T和ParamType的型别都为int
f(cx); //T和ParamType的型别都为int
f(rx); //T和ParamType的型别都为int
当传递的类型是一个指针时，有一种特殊情况，如下所示：
const char* const x = "123456";
f(x); // ParamType的类型是const char*
x的类型为const char* const，其中第一个const指的是该指针指向的内容不可修改，第二个const值得是该指针本身的值不可修改。进行型别推导时，会取消掉第二个const，第一个const则不能取消（一旦取消，则x指向的内容就可以更改了）。
一种特殊情况：数组实参
接下来还有一种特殊情况，那就是传递了一个数组。一般来说，讲一个数组按值传递给函数模板，形参将会被推导为指针型别：
template<typename T>
void f(T param);
const char name[] = "6666";
f(name); //T的型别为const char*
但神奇的是，尽管函数无法声明真正的数组型别的形参，它们却能够将形参声明成数组的引用！举个例子，如果我们这样修改f：
template<typename T>
void f(T& param);
f(name);
此时T会被推导为数组型别：const char[5]！而f的形参（param）则会被推导为数组类型的引用：const char(&)[5]。
我们可以利用这种特性来推断数组的大小：
template<typename T, std::size_t N>
constexpr std::size_t arraySize(T(&)[N])noexcept
{
return N;
}
int nums[] = {1,2,3,4,5};
int vals[arraySize(nums)];
惊不惊喜，意不意外？
auto的型别推导
auto实际上在大部分情况下可以看做是模板的型别推导，除了一种特殊情况。我们先看看auto如何与模板的型别推导对应的：
auto x = 27;
const auto cx = x;
const auto& rx = x;
上面三种情况完全可以用模板推导表达：
template<typename T>
void func_for_x(T param);
func_for_x(27);
template<typename T>
void func_for_cx(const T param);
func_for_x(x);
template<typename T>
void func_for_rx(const T& param);
func_for_x(x);
那么对应模板推导的三种情况如下：
auto x = 27; //情况3（x既不是指针也不是引用）
const auto cx = x; //情况3（x既不是指针也不是引用）
const auto& rx = x; //情况1（rx是个引用，但不是万能引用）
情况2同理：
auto && uref1 = x; //x的型别是int，且是左值，所以uref1的型别是int&
auto && uref2 = cx; //同上，uref2的型别是const int&
auto && uref3 = 27; //27是右值，因此uref3的型别是int&&
数组也一样：
const char name[] ="6666";
auto arr1 = name; //arr1的型别是const char*
auto& arr2 = name; //arr2的型别是const char(&)[5]
你看，一模一样。
那么特殊情况是什么呢？就是当我们用初始化表达式来初始化一个类型的时候：
int x{2};
auto x1 = {2};
上面的代码采用大括号来初始化对象，x的型别为int，而auto则不会将x1推导为int，而是std::initializer_list
如果采用模板型别推导，传入一个初始化表达式，则程序会直接报错:
template<typename T>
void f(T param);
f({1,2,3}); //程序无法推导T的类型，直接报错！
除非你手动指定param的类型为std::initializer_list
template<typename T>
void f(std::initializer_list<T> param);
除了这一条以外，auto的推导规则是和模板一模一样的。
