右值引用和左值引用

左值和右值概念

左值与右值是C语言中的概念,但C标准并没有给出严格的区分方式,一般认为：可以放在等号左边 或者能够取地址的称为左值, 放在等号右边的 或者不能取地址的称为右值 但是也不一定完全正确

什么是左值

左值是一个表示数据的表达式,例如 : 变量名 或 解引用的指针, 我们可以获取它的地址 以及 可以对它赋值

• 左值可以被取地址,也可以被修改 （const修饰的左值除外）
• 左值可以出现在赋值符号的左边.也可以出现在赋值符号的右边

例子:

int main()
{
	//以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
    
    int a = 10;
    int b = 20;
    // a和b都是左值,b既可以在=的左侧,也可在右侧,说明：左值既可放在=的左侧,也可放在=的右侧
    a = b;
    b = a;
	return 0;
}

什么是右值

右值也是一个表示数据的表达式, 如：字面常量、表达式返回值,传值返回函数的返回值(这个不能是左值引用返回)

• 右值不能被取地址.也不能被修改
• 右值可以出现在赋值符号的右边,但是不能出现在赋值符号的左边

例子:

int main()
{
	double x = 1.1, y = 2.2;

	//以下几个都是常见的右值
	10;   x + y; fmin(x, y);
    
	//错误示例（右值不能出现在赋值符号的左边）
	//10 = 1;
	//x + y = 1;
	//fmin(x, y) = 1;
	return 0;
}

右值本质就是一个临时变量或常量值,比如代码中的10就是常量值.表达式x+y和函数fmin的返回值就是临时变量.这些都叫做右值.

• 这些临时变量和常量值并没有被实际存储起来,这也就是为什么右值不能被取地址的原因,因为只有被存储起来后才有地址
• 需要注意的是:这里的函数的返回值是右值,指的是传值返回的函数,因为传值返回的函数在返回对象时返回的是对象的拷贝,这个拷贝出来的对象就是一个临时变量

而对于左值引用返回的函数来说.这些函数返回的是左值,例如string类实现的[]运算符重载函数,它返回的是一个字符的引用,因为它需要支持外部对该位置的字符进行修改.所以必须采用引用返回

• 之所以说这里返回的是一个左值.是因为这个返回的字符是被存储起来了的,是存储在string对象的_str对象当中的, 函数调用结束后,这个字符的空间捕获销毁, 因此这个字符是可以被取到地址的

区分左值和右值:

总结:不能简单地通过能否放在=左侧右侧或者取地址来判断左值或者右值, 要根据表达式结果或变量的性质
判断,

• 普通类型的变量 因为有变量名,可以取地址,都认为是左值

• const修饰的常量 不可修改,只读类型的理论应该按照右值对待,但因为其可以取地址,所以其实它是个左值

  • 如果只是const类型常量的定义,编译器不给其开辟空间,如果对该常量取地址时,编译器才为其开辟空间
  • C++11认为const修饰的常量是左值
  • const修饰符的左值,不能给他赋值,但是可以取它的地址

• 如果表达式运行结果或单个变量是一个引用则认为是左值

• 如果表达式的运行结果是一个临时变量或者对象 ,认为是右值

C++11对右值进行了严格的区分:

• C语言中的纯右值,比如：字符常量,表达式的返回值 a+b, 100
• 将亡值 比如：表达式的中间结果,函数按照值的方式进行返回的自定义类型对象 ,临时对象

左值引用 && 右值引用

C++98中提出了引用的概念,引用即别名,引用变量与其引用实体公共同一块内存空间,而引用的底层是通过指针来实现的,因此使用引用,可以提高程序的可读性, 无论左值引用还是右值引用,都是给对象取别名

左值引用

左值引用就是对左值的引用,给左值取别名: 通过“&”来声明.比如：

int main()
{
	//以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	//以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

右值引用

为了提高程序运行效率,C++11中引入了右值引用, 右值引用就是对右值的引用,给右值取别名:通过“&&”来声明

int Add(int x,int y)
{
    return x+y;
}
int main()
{
    double x = 1.1, y = 2.2;

    //以下几个都是常见的右值
    10;
    x + y;
    fmin(x, y);

    //以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double rr3 = fmin(x, y);
    int&& rRet = Add(10,20); 引用函数返回值,返回值是一个临时变量,为右值
    return 0;
}

需要注意的是,右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,这时这个右值可以被取到地址,并且可以被修改,如果不想让被引用的右值被修改,可以用const修饰右值引用

• 所以可以认为:右值引用之后的值是左值 ,即:下面rr1可以认为是左值
• 如果不想rr1被修改,可以用const去修饰右值引用 const int&& rr1 = 10

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;

	rr1 = 20; //可以对rr1取地址,也可以修改rr1
	rr2 = 5.5; //报错
	return 0;
}

左值引用可以引用右值吗

• 左值引用不能引用右值,因为这涉及权限放大的问题,右值是不能被修改的,而左值引用是可以修改,
• 但是const左值引用可以引用右值,因为const左值引用能够保证被引用的数据不会被修改

结论就是: const 左值引用 既可以引用左值也可以引用右值

template<class T>
void func(const T& val) //既可以接收左值,也可以接收右值
{
	cout << val << endl;
}
int main()
{
	// 左值引用只能引用左值,不能引用右值。
    int a = 10;
    int& ra1 = a;  // a为左值
    int& ra2 = 10;  //编译失败,因为10是右值,左值引用不可以引用右值
    
    // const左值引用既可引用左值,也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    
	string s("hello");
	func(s);       //s为左值
	func("world"); //"world"为右值
	return 0;
}

右值引用可以引用左值吗

• 右值引用只能引用右值,不能引用左值, 但是右值引用可以引用move以后的左值

move函数是C++11标准提供的一个函数,被move后的左值能够赋值给右值引用, move相当于改变了变量的属性

int main()
{
	int a = 10;

	//int&& r1 = a;     //右值引用不能引用左值
	int&& r2 = move(a); //右值引用可以引用move以后的左值
	return 0;
}

右值引用使用场景和意义

虽然const左值引用既能接收左值,又能接收右值,但左值引用终究存在短板,而C++11提出的右值引用就是用来解决左值引用的短板的

首先我们准备一份模拟实现的string的代码,类当中实现了一些基本的成员函数,并在string的拷贝构造函数和赋值运算符重载函数当中打印了一条提示语句, 下面我们来看看左值引用的短板,右值引用是如何补齐这个短板的

namespace Mango
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str; //返回字符串中第一个字符的地址
		}
		iterator end()
		{
			return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
		}
		//构造函数
		string(const char* str = "")
		{
			_size = strlen(str); //初始时,字符串大小设置为字符串长度
			_capacity = _size; //初始时,字符串容量设置为字符串长度
			_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
			strcpy(_str, str); //将C字符串拷贝到已开好的空间
		}
		//交换两个对象的数据
		void swap(string& s)
		{
			//调用库里的swap
			::swap(_str, s._str); //交换两个对象的C字符串
			::swap(_size, s._size); //交换两个对象的大小
			::swap(_capacity, s._capacity); //交换两个对象的容量
		}
		//拷贝构造函数（现代写法）
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str); //调用构造函数,构造出一个C字符串为s._str的对象
			swap(tmp); //交换这两个对象
		}
		//赋值运算符重载（现代写法）
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;

			string tmp(s); //用s拷贝构造出对象tmp
			swap(tmp); //交换这两个对象
			return *this; //返回左值（支持连续赋值）
		}
		//析构函数
		~string()
		{
			delete[] _str;  //释放_str指向的空间
			_str = nullptr; //及时置空,防止非法访问
			_size = 0;      //大小置0
			_capacity = 0;  //容量置0
		}
		//[]运算符重载
		char& operator[](size_t i)
		{
			assert(i < _size); //检测下标的合法性
			return _str[i]; //返回对应字符
		}
		//改变容量,大小不变
		void reserve(size_t n)
		{
			if (n > _capacity) //当n大于对象当前容量时才需执行操作
			{
				char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
				strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）
				delete[] _str; //释放对象原本的空间
				_str = tmp; //将新开辟的空间交给_str
				_capacity = n; //容量跟着改变
			}
		}
		//尾插字符
		void push_back(char ch)
		{
			if (_size == _capacity) //判断是否需要增容
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
			}
			_str[_size] = ch; //将字符尾插到字符串
			_str[_size + 1] = '\0'; //字符串后面放上'\0'
			_size++; //字符串的大小加一
		}
		//+=运算符重载
		string& operator+=(char ch)
		{
			push_back(ch); //尾插字符串
			return *this; //返回左值（支持连续+=）
		}
		//返回C类型的字符串
		const char* c_str()const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

左值引用的使用场景

• 左值引用做参数,防止传参时进行拷贝操作

• 左值引用做返回值,防止返回时对返回对象进行拷贝操作

例子:

void func1(Mango::string s)
{}
void func2(const Mango::string& s) //左值引用做参数,减少了拷贝
{}
int main()
{
	Mango::string s("hello world");
    // func1和func2的调用我们可以看到左值引用做参数减少了拷贝,提高效率的使用场景和价值
	func1(s);  //值传参
	func2(s);  //左值引用传参

	s += 'X';  //返回的是左值引用
	return 0;
}

因为string的+=运算符重载函数是左值引用返回的,因此在返回+=后的对象时不会调用拷贝构造函数,但如果将+=运算符重载函数改为传值返回,那么重新运行代码后你就会发现多了一次拷贝构造函数的调用,

我们都知道string的拷贝是深拷贝,深拷贝的代价是比较高的,我们应该尽量避免不必要的深拷贝操作,因此这里左值引用起到的作用还是很明显的,

综上所述,左值引用做参数和做返回值都可以提高效率

左值引用的短板:

• 左值引用虽然能避免不必要的拷贝操作,但左值引用并不能完全避免,
• 左值引用做返回值,并不能完全避免函数返回对象时不必要的拷贝操作

如果函数返回的对象是一个局部变量,该变量出了函数作用域就被销毁了,这种情况下不能用左值引用作为返回值,只能以传值的方式返回,这就是左值引用的短板

例子:

我们在Mango命名空间中实现一个to_string函数,因为to_string函数返回的是一个局部变量,所以这个to_string函数就不能使用左值引用返回

string to_string(int value)
{
    bool flag = true;
    if (value < 0)
    {
        flag = false;
        value = 0 - value;
    }
    Mango::string str;
    while (value > 0)
    {
        int x = value % 10;
        value /= 10;
        str += (x + '0');
    }
    if (flag == false)
        str += '-';
    
    std::reverse(str.begin(), str.end());
    return str;
}

此时调用to_string函数返回时,就一定会调用string的拷贝构造函数,比如：

int main()
{
	Mango::string s = Mango::to_string(1234);
	return 0;
}

只有拷贝的时候: 上述代码编译器做的优化:

实际当一个函数在返回局部对象时,会先用这个局部对象拷贝构造出一个临时对象,然后再用这个临时对象来拷贝构造我们接收返回值的对象,如下

在C++11标准出来之前,对于深拷贝的类来说这里就会进行两次深拷贝,所以大部分编译器为了提高效率都对这种情况进行了优化,这种连续调用构造函数的场景通常会被优化成一次, 因此按道理来说,在C++11标准出来之前这里应该调用两次string的拷贝构造函数,但最终被编译器优化成了一次,减少了一次无意义的深拷贝,（并不是所有的编译器都做了这个优化）

右值引用和移动语义

C++11提出右值引用就是为了解决左值引用的这个短板的,但解决方式并不是简单的将右值引用作为函数的返回值

右值引用和移动语句解决上述问题的方式就是,给当前模拟实现的string类增加移动构造和移动赋值方法,

移动构造

移动构造是一个构造函数,该构造函数的参数是右值引用类型的,移动构造本质就是将传入右值的资源窃取过来,占为己有,这样就避免了进行深拷贝,所以它叫做移动构造,就是窃取别人的资源来构造自己的意思

所以:在当前的string类中增加一个移动构造函数,该函数要做的就是调用swap函数将传入右值的资源窃取过来

//移动构造
string(string&& s)
	:_str(nullptr) , _size(0), _capacity(0)
{
    cout << "string(string&& s) -- 移动构造" << endl;
    swap(s);
}

移动构造和拷贝构造的区别:

• 在没有增加移动构造之前,由于拷贝构造采用的是const左值引用接收参数,因此无论拷贝构造对象时传入的是左值还是右值,都会调用拷贝构造函数,
• 增加移动构造之后,由于移动构造采用的是右值引用接收参数,因此如果拷贝构造对象时传入的是右值,那么就会调用移动构造函数（因为编译器走的是最匹配原则）,
• string的拷贝构造函数做的是深拷贝,而移动构造函数中只需要调用swap函数进行资源的转移,因此调用移动构造的代价比调用拷贝构造的代价小,

给string类增加移动构造后,对于返回局部string对象的这类函数,在返回string对象时就会调用移动构造进行资源的移动,而不会再调用拷贝构造函数进行深拷贝了

int main()
{
	Mango::string s = Mango::to_string(1234);
	return 0;
}

注意:虽然to_string当中返回的局部string对象是一个左值,但由于该string对象在当前函数调用结束后就会立即被销毁,我可以把这种即将被消耗的值叫做“将亡值”,比如匿名对象也可以叫做“将亡值”

既然“将亡值”马上就要被销毁了,那还不如把它的资源转移给别人用,因此编译器在识别这种“将亡值”时会将其识别为右值,这样就可以匹配到参数类型为右值引用的移动构造函数

拷贝构造和移动构造都存在的时候： 此处编译器做的优化:

如果编译器不优化这里应该调用两次移动构造,第一次调用移动构造用返回的局部string对象构造出一个临时对象,第二次调用移动构造用这个临时对象构造接收返回值的对象

而经过编译器优化后,最终这两次移动构造就被优化成了一次,也就是直接将返回的局部string对象的资源移动给了接收返回值的对象, 此外.C++11之后就算编译器没有进行这个优化问题也不大,因为不优化也就是调用两次移动构造进行两次资源的转移而已

问题：没有进行优化的时候,这个临时对象存在哪里?

必须是在调用该函数的栈帧当中,在这里,就是main函数的栈帧当中,！ 不可能在to_string函数的栈帧当中,因为to_string构造变量s的时候,to_string函数的栈帧已经销毁了, 而不能在寄存器当中,因为寄存器放不下！

所以：如果编译器不优化:to_string的返回对象str拷贝构造/移动构造临时对象,这个临时对象作为to_string的返回值再拷贝构造/移动构造s对象

优化的时候: to_string函数快结束的时候,返回前,直接用str构造对象s,省去了中间的临时对象

不能优化的场景:

如果我们不是用函数的返回值来构造一个对象,而是用一个之前已经定义出来的对象来接收函数的返回值,这时编译器就无法进行优化了

int main()
{
    Mango::string s;
    s = Mango::to_string(123);
    return 0;
}

这时当函数返回局部对象时,会先用这个局部对象拷贝构造出一个临时对象,然后再调用赋值运算符重载函数将这个临时对象赋值给接收函数返回值的对象,

• 由于原有operator=函数实现时复用了拷贝构造函数,因此代码运行后的输出结果会多打印一次拷贝构造函数的调用,这是原有operator=函数内部调用的,

• 编译器并没有对这种情况进行优化,因此在C++11标准出来之前,对于深拷贝的类来说这里就会存在两次深拷贝,因为深拷贝的类的赋值运算符重载函数也需要以深拷贝的方式实现,

• 但在深拷贝的类中引入C++11的移动构造后,这里仍然需要再调用一次赋值运算符重载函数进行深拷贝,因此深拷贝的类不仅需要实现移动构造,还需要实现移动赋值,

这里需要说明的是,对于返回局部对象的函数,就算只是调用函数而不接收该函数的返回值,也会存在一次拷贝构造或移动构造,因为函数的返回值不管你接不接收都必须要有,而当函数结束后该函数内的局部对象都会被销毁,所以就算不接收函数的返回值也会调用一次拷贝构造或移动构造生成临时对象,

不能优化的场景2:没有接收to_string函数的返回值,即:没有把这个返回值赋值给其它变量

此时str构造临时对象,临时对象作为to_string的函数调用表达式的返回值,此时没办法优化,没有优化的空间

int main()
{
   cout << Mango::to_string(123).c_str() << endl;
   //输出：string(const string& s) -- 深拷贝    123
   return 0;
}

问:移动构造延长了对象的生命周期,这句话是否正确?

不太正确,栈帧销毁了,对象还是得销毁了,移动构造只是把资源转移走了, 但是它曾经的资源还在

移动赋值

移动赋值是一个赋值运算符重载函数,该函数的参数是右值引用类型的,移动赋值也是将传入右值的资源窃取过来,占为己有,这样就避免了深拷贝,所以它叫移动赋值,就是窃取别人的资源来赋值给自己的意思

所以:在当前的string类中增加一个移动赋值函数,该函数要做的就是调用swap函数将传入右值的资源窃取过来

//移动赋值
string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动赋值" << endl;
    swap(s);
    return *this;
}

移动赋值和原有operator=函数的区别：

• 在没有增加移动赋值之前,由于原有operator=函数采用的是const左值引用接收参数,因此无论赋值时传入的是左值还是右值,都会调用原有的operator=函数,都能接收
• 增加移动赋值之后,由于移动赋值采用的是右值引用接收参数,因此如果赋值时传入的是右值,那么就会调用移动赋值函数（编译器走的是最匹配原则）,
• string原有的operator=函数做的是深拷贝,而移动赋值函数中只需要调用swap函数进行资源的转移,因此调用移动赋值的代价比调用原有operator=的代价小,

现在给string增加移动构造和移动赋值以后,就算是用一个已经定义过的string对象去接收to_string函数的返回值,此时也不会存在深拷贝

int main()
{
	Mango::string s;
	s = Mango::to_string(123);
}

此时当to_string函数返回局部的string对象时,会先调用移动构造生成一个临时对象,然后再调用移动赋值将临时对象的资源转移给我们接收返回值的对象,这个过程虽然调用了两个函数,但这两个函数要做的只是资源的移动,而不需要进行深拷贝,大大提高了效率

STL容器增加的接口

C++11标准出来之后.STL中的容器都增加了移动构造和移动赋值,

move函数

右值引用虽然不能引用左值,但也不是完全不可以,当需要用右值引用引用一个左值时,可以通过move函数将左值转化为右值,

move函数的名字具有迷惑性.move函数实际并不能搬移任何东西,该move函数唯一的功能就是将一个左值强制转化为右值引用,然后实现移动语义,

需要注意的是:一个左值被move以后,它的资源可能就被转移给别人了,因此要慎用一个被move后的左值

但是不一定被move以后就一定会被转走:如果仅仅是move,就不会有什么问题,但是如果把move之后的值给别人,就会调用移动构造,就会导致自己变为空

int main()
{
	Mango::string s1("hello");
	Mango::string s2("hello");

	Mango::string s3 = move(s1);//s1的资源被转移给s3,s1变为空
	move(s2);//s2的资源并没有被转走,因为没有人接收
}

右值引用的其他使用场景

C++11标准出来之后.STL中的容器除了增加移动构造和移动赋值之外.STL容器插入接口函数也增加了右值引用版本,

例如:vector和list为例,都增加了右值引用版本的插入函数

例子:如果list中存的是string对象,那么在调用push_back向list容器中插入元素时,可能会有如下几种插入方式

#include<list>
int main()
{
	list<Mango::string> lt;
	Mango::string s("1111");

	lt.push_back(s); //调用string的拷贝构造

	lt.push_back("2222");             //调用string的移动构造
	lt.push_back(Mango::string("3333")); //调用string的移动构造
	lt.push_back(std::move(s));       //调用string的移动构造
	return 0;
}

list容器的push_back函数需要先构造一个结点,然后将该结点插入到底层的双链表当中

1)在C++11之前list容器的push_back接口只有一个const左值引用版本,因此在push_back函数中构造结点时,不管左值还是右值,只能匹配到string的拷贝构造函数进行深拷贝

2)在C++11出来之后.string类提供了移动构造函数,并且list容器的push_back接口提供了右值引用版本,此时如果传入push_back函数的string对象是一个右值,那么在push_back函数中构造结点时,这个右值就可以匹配到string的移动构造函数进行资源的转移,这样就避免了深拷贝,提高了效率,

3)上述代码中的插入第一个元素时就会匹配到push_back的左值引用版本,在push_back函数内部就会调用string的拷贝构造函数进行深拷贝,而插入后面三个元素时由于传入的是右值,因此会匹配到push_back的右值引用版本,此时在push_back函数内部就会调用string的移动构造函数进行资源的转移

完美转发

万能引用

在模板当中,&&不代表右值引用,而是万能引用,其既能接收左值又能接收右值

template<class T>
void PerfectForward(T&& t) //这里不需要加const,因为是模板,你传过来什么就是什么
{
	//,,,
}

右值引用和万能引用的区别

右值引用需要是确定的类型,而万能引用是根据传入实参的类型进行推导,如果传入的实参是一个左值,那么这里的形参t就是左值引用,如果传入的实参是一个右值,那么这里的形参t就是右值引用

小例子

下面重载了4个Func函数,这四个函数的参数类型分别是左值引用、const左值引用、右值引用和const右值引用

void Func(int& x)
{
	cout << "左值引用" << endl;
}
void Func(const int& x)
{
	cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
	cout << "右值引用" << endl;
}
void Func(const int&& x)
{
	cout << "const 右值引用" << endl;
}

在主函数中调用PerfectForward函数时分别传入左值、右值、const左值和const右值,在PerfectForward函数中再调用Func函数

template<class T>
void PerfectForward(T&& t) //万能引用
{
	Func(t);
}
int main()
{
	int a = 10;
	PerfectForward(a);       //a是左值
	PerfectForward(move(a)); //move(a)是右值

	const int b = 20;
	PerfectForward(b);       //const 左值
	PerfectForward(move(b)); //const 右值
	return 0;
}

我们发现,最后调用的都是左值引用/const左值引用版本的Func函数

原因:

由于PerfectForward函数的参数类型是万能引用,因此既可以接收左值也可以接收右值,而我们在PerfectForward函数中调用Func函数,就是希望调用PerfectForward函数时传入左值、右值、const左值、const右值,能够匹配到对应版本的Func函数

• 实际调用PerfectForward函数时传入左值和右值,最终都匹配到了左值引用版本的Func函数,调用PerfectForward函数时传入const左值和const右值,最终都匹配到了const左值引用版本的Func函数,

根本原因就是,右值被引用后会导致右值被存储到特定位置,这时这个右值引用可以被取地址,并且可以被修改,所以在PerfectForward函数中调用Func函数时会将t识别成左值

• 也就是说:右值引用的变量实际上是个左值,经过参数传递,被认为是左值

也就是,右值经过一次参数传递后其属性会退化成左值,如果想要在这个过程中保持右值的属性,就需要用到完美转发

完美转发保持值的属性

只要右值引用,再传递其它函数调用,想在参数传递过程中保持其原有的右值属性,需要在传参时调用forward函数进行完美转发,(它是std命名空间下的一个函数) 否则就是以左值的属性传递

template<class T>
void PerfectForward(T&& t)
{
	Func(std::forward<T>(t));
}

经过完美转发后,调用PerfectForward函数时传入的是右值就会匹配到右值引用版本的Func函数,传入的是const右值就会匹配到const右值引用版本的Func函数,这就是完美转发的价值

此时对于上述的代码就能正确的进行匹配了

完美转发的使用场景

下面模拟实现了一个简化版的list类,类当中分别提供了左值引用版本和右值引用版本的push_back和insert函数

namespace Mango
{
	template<class T>
	struct ListNode
	{
		T _data;
		ListNode* _next = nullptr;
		ListNode* _prev = nullptr;
	};
	template<class T>
	class list
	{
		typedef ListNode<T> node;
	public:
		//构造函数
		list()
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//左值引用版本的push_back
		void push_back(const T& x)
		{
			insert(_head, x);
		}
		//右值引用版本的push_back
		void push_back(T&& x)
		{
			insert(_head, std::forward<T>(x)); //完美转发,为了让参数传递下去保持属性
		}
		//左值引用版本的insert
		void insert(node* pos, const T& x)
		{
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = x;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
		//右值引用版本的insert
		void insert(node* pos, T&& x)
		{
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = std::forward<T>(x); //完美转发！保持属性,调用移动赋值

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
	private:
		node* _head; //指向链表头结点的指针
	};
}

问:上面push_back和insert函数的参数T&&是右值引用还是万能引用?

是右值引用！ 因为在list对象创建时这个类就被实例化了,后续调用push_back和insert函数时,参数T&&中的T已经是一个确定的类型了,而不是在调用push_back和insert函数时才进行类型推导的,

下面定义list对象.list容器中存储的就是我们自己实现的string类,分别传入左值和右值调用不同版本的对象进行插入

• 此时我们的string类中是实现了移动构造和移动赋值的

int main()
{
	Mango::list<Mango::string> lt;
	Mango::string s("1111");
	lt.push_back(s);      //调用左值引用版本的push_back

	lt.push_back("2222"); //调用右值引用版本的push_back
	return 0;
}

我们的string类中,operator=用的是现代写法,拷贝构造一个临时对象,然后和当前对象交换！所以有一次深拷贝

分析:

调用左值引用版本的push_back函数插入元素时,会调用我们自己实现的string类中的operator=函数进行深拷贝,而调用右值引用版本的push_back函数插入元素时,只会调用string的移动赋值进行资源的移动,

2)因为实现push_back函数时复用了insert函数的代码

• 对于左值引用版本的push_back函数,在调用insert函数时只能调用左值引用版本的insert函数,而在insert函数中插入元素时会先new一个结点,然后将对应的左值拷贝赋值给该结点,因此会调用string原有的operator=函数进行深拷贝,
• 对于右值引用版本的push_back函数,在调用insert函数时就可以调用右值引用版本的insert函数,在右值引用版本的insert函数中也会先new一个结点,然后将对应的右值移动赋值给该结点,因此这里就是调用string的移动赋值函数进行资源的移动

注意:右值引用版本的push_back函数当中需要使用完美转发,才能保持右值的属性去调用右值版本的insert函数, 否则右值引用版本的push_back接收到右值后,该右值的右值属性就退化成左值,此时在右值引用版本的push_back函数中调用insert函数,也会匹配到左值引用版本的insert函数,最终调用的还是原有的operator=函数进行深拷贝

注意点2:,除了在右值引用版本的push_back函数中调用insert函数时,需要用完美转发保持右值原有的属性之外,在右值引用版本的insert函数中用右值给新结点赋值时也需要用到完美转发,否则在赋值时也会将其识别为左值,导致最终调用的还是左值版本的operator=函数

总结起来就是: 只要想保持右值的属性,在每次右值传参时都需要进行完美转发,实际STL库中也是通过完美转发来保持右值属性的,

如果我们这里用的是库里面的list容器:

#include<list>
int main()
{
	list<Mango::string> lt;
	Mango::string s("1111");//调用左值引用版本的push_back
	lt.push_back(s);      

	lt.push_back("2222"); //调用右值引用版本的push_back
	return 0;
}

如果将刚才测试代码中的list换成STL当中的list.

• 调用左值引用版本的push_back插入结点,在构造结点时会调用string的拷贝构造函数,
• 调用右值引用版本的push_back插入结点,在构造结点时会调用string的移动构造函数,

而用我们刚才自己实现的list时,调用的是string原有的operator=和移动赋值,这是为什么呢?

原因是因为我们模拟实现的list容器,是通过new操作符为新结点申请内存空间的,在申请内存后会自动调用构造函数对进行其进行初始化，所以相当于是一个已经存在的对象, 因此在后续用左值或右值对其进行赋值时,就会调用对应的operator=或移动赋值进行深拷贝或资源的转移

string s1("hello");
string s2 = s1;//一个存在的对象去初始化有一个正在构造的对象 -> 拷贝构造
//赋值是已经存在的对象给已经存在的对象
string s3;
s3 = s1;//一个存在的对象去初始化一个已经存在的对象 -> 拷贝赋值

而STL库中的容器都是通过空间配置器获取内存的,因此在申请到内存后不会调用构造函数对其进行初始化,而是后续调用定位new,用左值或右值对其进行拷贝构造,因此最终调用的就是拷贝构造或移动构造,

如果想要得到与STL相同的实验结果,可以使用malloc函数申请内存,这时就不会自动调用构造函数进行初始化,然后在用定位new的方式用左值或右值对申请到的内存空间进行构造,这时调用的对应就是拷贝构造或移动构造,

节点是从内存池来的,调用定位new,把一个已经存在的string对象构造到当前正在构造的节点上,是拷贝构造/移动构造