首先要分清：
C++里的值只有两种值：左值、右值。—— 其本质应该是内存中存储的值/instance分两种：一种是持久的，一种是“短暂的”
也只有两种引用： 左值引用、右值引用。 ——引用,就是这个内存地址的助记符（别名）。
1. 左值引用 需绑定、也只能绑定 左值。
同理，右值引用 需绑定、也只能绑定 右值。
2. 有两种特别的引用既可以绑定左值、又可以绑定右值。分别是：
①const T&
② universal reference ： “T&& t在发生自动类型推断的时候，它是未定的引用类型”—— 指的是template的推断/ auto推断
3. int&& t = getTemp(); 则“getTemp()”是右值
但用t绑定该右值后，该右值的生命周期就被延长（和t的生命周期一样）。
注意，此时t已经是持久的值，而且可以对其取地址的。（赋值也没编译报错~）
★ 此时： ① t是右值引用 ② t是一个左值 “绑定了右值的右值引用本身 是一个左值” 【这符合 “ 左值持久、右值短暂”】
再看函数调用： 传参的实质是把实参传递给形参。 其实质的过程却可以细分一下！
实参 ——> 形参 = return # ——> “ret”
R res ( in ) ;
第1种： 值 ——> 引用（是引用去绑定值的过程）
【左值—> 左值引用】 int i = 1; foo(int& m); ——> foo(i); 则“传参” 是用形参的引用 绑定实参这个值。
【右值—> 右值引用】 T GetTemp(); foo(T&& m); ——> foo( GetTemp() ); （此时在函数内 可以 move(m) 后 接管这个右值的临时资源了）
第2种： 值 ——> 值 是给我提供个对象,我根据它再构造一个的过程（拷贝/移动）
【左值】 int t = 1; foo(int p); ——> foo(t); 则“传参”是用 t 拷贝值给 p。 （值拷贝） —— 前提同下。可通过move(lvalue) 将左值转换为右值，以进行移动
【右值】 T GetTemp(); foo(T m); ——> foo( GetTemp() ); （值移动） ——前提: 该类型已定义了 const T&的拷贝构造 、 T&&的移动构造
第3种： 引用 ——> 值 值 是给我提供个对象,我根据它再构造一个的过程（拷贝/移动）
【左值(引用) 】 int i =1; int& t = i; foo(int m); ——> foo(t); ★ 对于左值来说，使用左值、左值引用 在传递时 没有区别。都是指 那个持久的值。 相当于第2种“左值——>左值” （值拷贝）
【右值引用（左值）】 T&& t = GetTemp(); foo(T m); ——> foo(t); 相当于第2种“左值——>左值” ： m是临时对象“GetTemp()”的拷贝 （值拷贝）
第3种： 引用 ——> 引用（是引用去绑定值的过程） + 不存在引用的引用。
【左值(引用) —> 左值引用】 int i =1; int& t = i; foo(int& m); ——> foo(t); 则“传参”就相当于 int& ref2 = ref1;
【右值引用（左值）——> 左值引用/ const 左值引用 / universal reference】 T&& t = GetTemp(); foo(T&& m); ——> foo(t)无法匹配，“右值引用m 无法绑定 左值t”
T&& t = GetTemp(); foo(T& m); ——> foo( t); // 引用到了一个右值，但函数会以为自己引用的是左值
函数返回时 T GetTemp() { return T();} 会发生 T() 这个右值到 “GetTemp()” 这个临时变量的移动。
那么， 函数调用传参时， 会发生实参到形参的移动吗 ？？？
肯定会，比如unique_ptr, iostream 这种只能移动的东西。
当然可以：和返回时一样，去 右值去适配 T的构造就行： GetTemp() ——> T ， 即 foo(T t) ; 调用 foo(GetTemp())
引用折叠
① 对一个类型，你可以使用该类型的两种引用： 左值引用 int& 、右值引用 int&&
你② 不能直接定义 “引用的引用”： int& && i; int&& & i; 这些写法都是报错的。
但是，你可以把引用定义为一个新的类型：
typedef int& iR; // iR 就是 左值引用int&
typedef int&& iRR; // iRR 就是右值引用 int&&
iR, iRR作为新的类型，可以定义它们的两种引用： iR& , iR&& 以及 iRR& , iRR &&
这样仿佛出现了“引用类型 的引用”。
这时候，就需要“引用折叠”。 —————— 所以，这是C++为了实现 ①+② 而规定的规则。（我觉得的）
规则就是：凡是右左值引用参与的情况下，最终的类型都会变为左值引用，只有全部为右值引用的情况下才会变为右值引用。
=============================================================================
完美转发
C++11引入了完美转发：在函数模板中，完全依照模板的参数的类型（即保持参数的左值、右值特征），将参数传递给函数模板中调用的另外一个函数。
template<typename T>
void foo(T&& t );
一：用左值去调：
int i = 1; foo(i); 此时 模板推断其类型参数 T 为 int& ——> 故 T&& 为 int&+ && ， 折叠为 int& ——> 所以生成的函数实例为 foo(int& t); t 是左值。
二：用右值去调：
foo(3); 此时 模板推断其类型参数 T 为 int&& ——> 故 T&& 为 int&& + && ， 折叠为 int&& ——> 所以生成的函数实例为 foo(int&& t); t 是右值。
p.s. 模板的参数类型推导规则 ，请另学。
参考：C++11 reference collapsing and perfect forward (引用折叠以及完美转发)
★ 答案，这下讲明白了！
