引用
计算机专业大一的基础内容之一，值传递和引用传递：
void foo(int& a)
{
a = 2;
}
void bar(int a)
{
a = 3;
}
int main()
{
int a = 1;
foo(a);
cout << a << endl;
bar(a);
cout << a << endl;
return 0;
}
这里会输出两个2：
2
2
当然用指针可以达到类似的效果，但不完全等价：
void foo(int* a)
{
*(a) = 2;
}
void bar(int a)
{
a = 3;
}
int main()
{
int a = 1;
foo(&a);
cout << a << endl;
bar(a);
cout << a << endl;
return 0;
}
用指针太容易出现内存问题了，引用更加安全，指针可能会出现这样的情况：
void foo(int* a)
{
int b = 0;
a = &b;
*(a) = 2; //改变了a指向的地址，所以修改不对main中的a起效
}
void bar(int a)
{
a = 3;
}
int main()
{
int a = 1;
foo(&a);
cout << a << endl;
bar(a);
cout << a << endl;
return 0;
}
左值引用与右值引用
众所周知C++允许程序员非常自由地操作内存，为了更加灵活地使用引用，C++11添加了右值引用的特性。
试想如下场景：
void foo(int a)
{
bar(a);
}
void bar(const int a)
{
cout << a << endl;
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
这会导致foo和bar函数每次都在栈内存上新建一个变量，于是我们加入引用以节省内存：
void foo(int& a)
{
bar(a);
}
void bar(const int& a)
{
cout << a << endl;
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
这会导致编译错误，因为参数int& a是一个左值，而常量1是一个右值，通过修改int&为const int&可以部分解决这个问题：
void foo(const int& a) // const & binds to everything
{
bar(a);
}
void bar(const int& a)
{
cout << a << endl;
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
但是这样在foo中就无法修改a的值，不够灵活，于是我们加入右值引用的foo实现：
void bar(const int& a)
{
cout << a << endl;
}
void foo(int&& a)
{
cout << "rvalue" << endl;
bar(a);
}
void foo(int& a)
{
cout << "lvalue" << endl;
bar(a);
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
看似完美解决了问题，但是这是单个参数的情况，如果是2个参数，那么就要重载4个函数，3个参数就要重载8个函数……
于是有了万能引用：
void bar(const int& a)
{
cout << a << endl;
}
template<typename T>
void foo(T&& a)
{
bar(a);
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
似乎一切正常，但是仅仅这样是不够的，如果我们重载一下bar，就会发现，foo把左值和右值引用都转化成了左值：
void bar(int& a)
{
cout << "lvalue" << endl;
}
void bar(int&& a)
{
cout << "rvalue" << endl;
}
template<typename T>
void foo(T&& a)
{
// a here is always a left reference
bar(a);
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
由于自动类型推导（常数1被推导为int型），这将输出两个lvalue，显然不符合我们的预期，此时，搭配std::forward才能正确地实现完美转发：
void bar(int& a)
{
cout << "lvalue" << endl;
}
void bar(int&& a)
{
cout << "rvalue" << endl;
}
template<typename T>
void foo(T&& a)
{
bar(forward<T>(a));
}
int main()
{
int a = 2;
foo(a);
foo(1);
}
这将输出：
lvalue
rvalue
引用折叠
上述内容还涉及一个问题，引用的引用如何定义？
对于如下万能引用：
template<typename T>
void foo(T&& a);
当T的类型为一个int&时，a的类型事实上是int& &&，也就是一个左值引用的右值引用，但是C++不允许类似int& &&这样的类型声明，它要么是int&要么是int&&，于是就有了引用折叠：
int& && -> int&
int& & -> int&
int&& & -> int&
int&& && -> int&&
可以看到左值引用具有传染性，类似一个或门，仅有右值引用的右值引用折叠结果为右值引用，这也是std::forward的实现原理：
template<typename T>
T&& forward(typename std::remove_reference<T>::type& t) noexcept {
return static_cast<T&&>(t);
}
template<typename T>
T&& forward(typename std::remove_reference<T>::type&& t) noexcept {
static_assert(!std::is_lvalue_reference<T>::value, "Invalid argument: cannot forward an lvalue as an rvalue.");
return static_cast<T&&>(t);
}
可以看到，std::forward通过std::remove_reference去除了t的引用限定符，也就是不管类型T加了多少引用限定符，都回归到基本类型，比如一个int& &&，经过std::remove_reference，会得到一个int类型，通过重载，自动调用左值或右值版本，并在最后用static_cast<T&&>返回一个t的右值引用，又由于引用折叠，t如果是一个左值引用，比如int&，那么返回的就是int& &&，最终还是一个int&，同理，int&& &&返回的就是一个int&&。
相关话题：std::move
设想如下代码：
void bar(int& a)
{
cout << "lvalue" << endl;
}
void bar(int&& a)
{
cout << "rvalue" << endl;
}
template<typename T>
void foo(T&& a)
{
bar(forward<T>(a));
}
void test(int& a)
{
cout << "ltest" << endl;
foo(a);
}
void test(int&& a)
{
cout << "rtest" << endl;
foo(a);
}
int main()
{
int a = 2;
test(a);
test(2);
}
在执行test函数时，可以正常重载对应类型的函数，但是test调用foo时，由于自动类型推导，两次都是lvalue，输出为：
ltest
lvalue
rtest
lvalue
使用std::move，可以将变量显式转换为右值引用：
void bar(int& a)
{
cout << "lvalue" << endl;
}
void bar(int&& a)
{
cout << "rvalue" << endl;
}
template<typename T>
void foo(T&& a)
{
bar(forward<T>(a));
}
void test(int& a)
{
cout << "ltest" << endl;
foo(a);
}
void test(int&& a)
{
cout << "rtest" << endl;
foo(move(a)); // same as std::forward<int&&>(a) here
}
int main()
{
int a = 2;
test(a);
test(2);
}
这将输出：
ltest
lvalue
rtest
rvalue
如上场景使用move实现了类似forward的功能，两者又是有区别的，forward只是保持来源的引用类型不变，而move可以将左值转变为右值，比如想要调用移动构造函数而非拷贝构造函数来节约内存时，就可以通过move实现。