大家好，我叫徐锦桐，个人博客地址为www.xujintong.com。平时记录一下学习计算机过程中获取的知识，还有日常折腾的经验，欢迎大家访问。
在写STL源码的时候遇到的问题，在这里写一篇笔记记录一下。
一、引用折叠
引用折叠表示了一个值被引用多次时（只有在模板推导时候），会生成什么类型。
T& & 折叠成 T&
T& && 折叠成 T&
T&& & 折叠成 T&
T&& && 折叠成 T&&
其实总结起来就是，只有两次都是右值引用的时候才是T&&，即T&& && 折叠成 T&&，其他都是转换成左值引用T&。
二、左值引用
左值引用，就是个别名，将一个变量绑定到另一个变量上。
int a = 10;
int &b = a; // 左值引用
const int &c = 10; // 常量左值引用
b = 20;
std::cout << a << std::endl; // 20
修改引用变量会影响原来的变量的值，但是 const int & 不能修改原对象的值（中间的int可以更换为其他类型）。
一般来说，函数传参的时候是拷贝传参，也就是将变量复制到一个临时变量，再将临时变量传入函数，最后销毁临时变量。这里涉及到了内存的拷贝，消耗的时间比较长。但是如果在传参的时候使用左值引用，不会涉及到内存的拷贝，因为是别名，相当于直接修改原变量了。
void left_value(int& x) {
x = 200;
}
int main()
{
int value = 10;
left_value(value);
std::cout << value << std::endl; // 200
return 0;
}
当然如果是const&的话，虽然不涉及到内存的拷贝过程，但是不能修改原变量。
void left_value(const int& x) {
x = 200; // error: assignment of read-only reference 'x'
}
int main()
{
int value = 10;
left_value(value);
std::cout << value << std::endl; // 200
return 0;
}
这里函数传参的时候，为什么 int 能匹配到 int& 或者 const int& 呢？
当你将一个int类型传递给int&参数时，c++会执行一个类型转换，将int隐式的转换为int&，另一个同理。注意：int、int&、const int& 在匹配函数的时候优先级一样，同时出现会发生歧义错误。
函数传参的时候隐式转换很常见。
void left_value(int num) {
std::cout << num << std::endl;
}
int main()
{
float a = 1.5;
left_value(a); // 1
return 0;
}
传入的时候隐式的将float类型转化为int类型。
但是用函数重载就可以解决这个问题。
void left_value(int num) {
std::cout << num << std::endl;
}
void left_value(float num) {
std::cout << num << std::endl;
}
int main()
{
float a = 1.5;
left_value(a);
return 0;
}
会调用最适合的函数，那如果没有的话就只能进行隐式的类型转换了。
三、右值引用
右值引用是c++11引用的新特性。就是左值引用是给一个变量加别名，而右值引用就是绑定变量到一个临时值上，临时变量的生命周期和新左值的生命周期绑定，原来的临时变量销毁。
int &&d = 10; // 右值引
d = 200; // 此时 d 是变量是左值
引用在c++中是一个特别的类型，因为它的值类型和变量类型不一样, 左值/右值引用变量的值类型都是左值, 而不是左值引用或者右值引用。 这句话意思非常重要，简单来说，看上面代码，一开始将d绑定到了10上面，然后又将d赋值，在int &&d=10 之后，每次使用d，d都是作为一个左值使用的。一个右值引用变量在使用上就变成了左值，已经不再携带其是右引用这样的信息，只是一个左值。
右值引用也是提高性能用的。
vector<string> v;
string s = "teststring";
v.push_back(s);
上面这个代码，用了一个临时变量。假如我们啥都不干那么是怎么进行的呢，首先会先创建一个临时字符串，然后将这个临时字符串拷贝到v的内存上，然后再销毁这个临时字符串。中间进行内存的开辟和销毁，在一般数据上性能没啥问题，如果是数据特别多的话，性能就会严重下降。
但如果我们用右值引用，如下代码。
vector<string> v;
string s = "teststring";
v.push_back(std::move(s));
这里的std::move()是将一个左值强制转换为右值，下面我会讲，现在就知道能将左值强制转化为右值就行了。
中间的过程就变成了，创建一个临时字符串，然后直接将这个临时字符串挂载到v上面。是不是中间少了好多过程，性能也大大的提高了。
四、万能引用
模板编程中，有的时候需要传入左值也传入右值引用。
下面这个只能传入一个左值，如果传入右值就会报错。
template <typename T>
void func(T& value) {
std::cout << "函数调用" << std::endl;
}
int main()
{
int value = 10;
func(value);
func(10); // 报错
return 0;
}
这时候就用到了我们的万能引用T&&。
template <typename T>
void func(T&& value) {
std::cout << "函数调用" << std::endl;
}
int main()
{
int value = 10;
func(value);
func(10);
return 0;
}
解释一下:
能同时传入左值引用和右值引用。
如果是左值，T先会推导成T&，然后再发生引用折叠，如果是右值引用，T会推导成T&&。
比如说，func(value)中的value是一个左值，传入后T会推导成T&，然后再后后面的&&发生折叠引用，就会变成T&。
func(10)中的10是一个右值，T会推导成T&&，然后再和后边的&&发生引用折叠，最后变成了T&&。
**T&&只在
五、move
std::move它其实啥都没干，就是强制将左值转化为右值。
show you the code。
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
这里面的 std::remove_reference<_Tp>，就像去除变量的引用，假如_Tp是int&&，最后返回type是个int。
std::remove_reference<_Tp>的源代码如下。
/// remove_reference
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
六、完美转发
完美转发是配合万能引用使用的，通过万能引用传入左值和右值的参数，然后通过完美转发保留这个属性，转发给对应的重载函数。
show the code。
/*
函数模板的重载
*/
template <typename T>
void to_forward(T& value) {
std::cout << "调用的左值函数" << std::endl;
}
template <typename T>
void to_forward(T&& value) {
std::cout << "调用的右值函数" << std::endl;
}
template <typename T>
void func(T&& arg) {
to_forward(arg); // 调用左边值函数
}
int main(){
int value = 10;
func(std::move(value));
}
在这个代码中，func函数中的to_forward函数最终会调用to_forward(T& value)，虽然传入的是右值，一个右值引用变量在使用上就变成了左值，已经不再携带其是右引用这样的信息，只是一个左值，所以这里调用的是左值的重载函数。
首先展示一下std::forward的源码。
/**
* @brief Forward an lvalue.
* @return The parameter cast to the specified type.
*
* This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
/**
* @brief Forward an rvalue.
* @return The parameter cast to the specified type.
*
* This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
这里有两个重载的函数，一个对应左值一个对应右值。
forward(typename std::remove_reference<_Tp>::type& __t)这个是先将_t的类型去掉引用，然后加上个&，也就是最后是左值类型。
那下面forward(typename std::remove_reference<_Tp>::type&& __t)那个肯定就是右值的了。
这里也用到了引用折叠，连个返回的方法是一样的，都是return static_cast<_Tp&&>(__t)，如果_Tp是&，然后在和后面的&&折叠就是左值了；如果_Tp是&&，然后再和后面的&&折叠还是&&。
std::move和std::forward其实什么都没做，只是强制转换了一下类型。
看下面这个代码，这个是正确的。我们通过完美转发保留了这个左值还是右值的属性，然后再传给另一个函数。
#include <iostream>
#include <utility>
/* 完美转发 + 万能引用 + std::move */
/*
函数模板的重载
*/
template <typename T>
void to_forward(T& value) {
std::cout << "调用的左值函数" << std::endl;
}
template <typename T>
void to_forward(T&& value) {
std::cout << "调用的右值函数" << std::endl;
}
/*
万能引用：
能同时传入左值引用和右值引用
如果是左值，T先会推导成T&，然后再发生引用折叠
入股是右值引用，则会什么都不干
利用完美转发std::forward:
先通过万能引用可以传入左值引用和右值引用
然后通过完美转发（能保留传入时候是左值引用还是右值引用的属性，然后转发到对应的函数重载中
*/
template <typename T>
void func(T&& arg) {
// 保留左值和右值的属性
to_forward(std::forward<T>(arg));
}
int main() {
int value = 10;
int& value_l_refernce = value;
func(value); // 调用的左值引用函数
func(value_l_refernce); // 调用的左值引用函数
func(100); // 调用的右值引用函数
int&& value_r_refernce = 30;
// 右值引用使用后，之后调用这个变量都是作为左值
func(value_r_refernce); // **调用的左值引用**
func(std::move(value)); // 调用的右值引用
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
