引用叠加规则和模板参数类型推导规则

1.基础知识

读这篇文章之前,你该掌握如下的知识，c++的左值和右值，以及模板的基础知识。
c++的左值和右值文章可以参考这篇 话说C++中的左值、纯右值、将亡值

template<typename T> // 尖括号里的T叫模板参数
void f(T x); // 圆括号里的T叫调用参数
// 参数类型（即x的类型）和模板参数类型（即T的类型）是不同的概念
// 推断时用来替换模板参数的叫模板实参，比如
int i;
f(i); // 模板实参是int

这里T是有两个名称的，一个叫模板参数，一个叫调用参数，这里模板参数的推导说的是template<typename T> 这里的T

推断规则

• 调用参数不是引用或指针（即T）：

1如果表达式不是指针，T和x的类型都是非引用类型，cv限定符去除。比如表达式是int、int&、int&&、const int、const int&，只要不是指针，T和x最终都是int；
2.如果是指针，T和x都是对应的指针类型，cv限定符保留；

template<typename T>
void f(T x);

// 为了方便，只指明类型不做初始化
int i;
int* p;
const int* q;
f(i); // T和x都是int
f(p); // T和x都是int*
f(q); // T和x都是const int*

• 调用参数是引用或指针（即T&或T*）：

1.对于T&，不管表达式是什么，x一定是左值引用类型（表达式是指针则x是指针的引用），cv限定符保留；
2.对于T*，和T&类似，x一定是指针类型，cv限定符保留；

知道x类型则可以很容易知道T类型；通过下面的例子可以发现，T一定是非引用类型；

template<typename T>
void f(T& x);

int i;
int& r;
int&& rr;
const int& cr;
int* p;
const int* const q;
f(i); // x是int& => T&是int& => T是int
f(r); // x是int& => T&是int& => T是int
f(rr); // x是int& => T&是int& => T是int
f(cr); // x是const int& => T&是const int& => T是const int
f(p); // x是int* & => T&是int* & => T是int*
f(q); // x是const int* const & => T&是const int* const & => T是const int* const


template<typename T>
void f2(T* x);

f2(&i); // x是int* => T*是int* => T是int
f2(&cr); // x是const int* => T*是const int* => T是const int
f2(p); // x是int* => T*是int* => T是int
f2(q); // x是const int* => T*是const int* => T是const int

• 调用参数是转发引用（即T&&）：

1.不管表达式是什么，x都是引用类型：
2.如果表达式是左值，则x是左值引用，cv限定符保留，即采用和T&相同的规则，只不过因为T&&多了个&，为了转为左值引用需要引入引用折叠的概念。通过下面的例子可以发现，T一定是左值引用类型，这是T被推断为引用类型的唯一情况；
3.如果表达式是右值，则x是右值引用类型；

引用折叠规则

template<typename T>
void f(T&& x);

int i;
int& r;
int&& rr;
const int& cr;
int* p;
const int* const q;
// 都是左值，采用的规则和T&的相同
f(i); // x是int& => T&&是int&，int& + && = int& => T是int&
f(r); // x是int& => T&&是int&，int& + && = int& => T是int&
f(rr); // x是int& => T&&是int&，int& + && = int& => T是int&
f(cr); // x是const int& => T&&是const int& => T是const int&
f(p); // x是int* & => T&&是int* & => T是int* &
f(q); // x是const int* const & => T&&是const int* const & => T是const int* const &

// 表达式是右值
f(42); // x是int&& => T&&是int&& => T是int

最后再来给2和3 总结下：

template<typename T>
void f(T&& fpar)//formal parameter 形参
{
    //函数体
}
//调用
int a=1;
int& apar=a;//actual parameter 实参
f(apar);

总结

引用叠加规则的规律是：
调用前fpar与apar中有一个是&，结果（即调用后fpar的实际类型）就是&；只有当fpar与apar都是&&时，结果才是&&

---

模板参数类型推导规则的规律是：
只有调用前fpar是&&，apar是&时，调用后T的实际类型才是A&，其余3种情况下都是A。

参考资料：
C++11 图说VS2013下的引用叠加规则和模板参数类型推导规则
https://www.zhihu.com/question/303493908