C++11--右值引用

基本概念

左值和右值

左值引用和右值引用

右值引用使用场景和意义

左值引用使用场景

左值引用的短板

右值引用和移动语义

右值引用引用左值

右值引用的其他使用场景

完美转发

万能引用

完美转发保持值得属性

完美转发使用得场景

基本概念

左值和右值

什么是左值?

左值是一个表示数据的表达式,如变量名或解引用的指针.

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

int mian()
{
	//一下的p,b,c*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	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类实现的[]运算符的重载函数:

		char& operator[](size_t i)
		{
			assert(i < _size);
			return _str[i];
		}

详细讲解:c++STL---string(模拟实现)-CSDN博客

这里的[]运算符的重载函数返回的是一个字符的引用,因为他需要支持外部对该位置的字符进行修改,所以必须采用左值引用返回.之所以说这里返回的时一个左值,时因为这个返回的字符时被存储起来的,时存储在string对象的_str对象中的,因此这个字符时可以被取到地址的.

左值引用和右值引用

传统的C++语法中就有引用的语法,而C++11中新增了右值引用的语法特性,为了进行区分,于是C++11之前的引用就叫做左值引用.但是无论左值引用还是右值引用,本质都是给对象取别名.

左值引用

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

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;
}

右值引用

右值引用就是对右值的引用,给右值取别名,通过"&&"来声明.比如:

int mian()
{
	double x = 1.1, y = 2.2;
	//一下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);
	//一下几个都是对右值的引用
	int&& rr = 10;
	double&& rr2 = x + y;
	double rr3 = fmin(x, y);
	return 0;
}

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

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	rr1 = 20;
	rr2 = 5.0; // 报错
	return 0;
}

左值引用可以引用右值吗?

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

因此const左值引用即可以引用左值,也可以引用右值.比如:

template<class T>
void func(const T& val)
{
	cout << val << endl;
}
int main()
{
	string s("hello");
	func(s);
	func("world");
	return 0;
}

右值引用可以引用左值吗?

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

move函数是C++11标准提供的一个函数,被move后的左值能够赋值给左值引用.比如:

int main()
{
	int a = 10;

	int&& r2 = move(a);
	return 0;
}

右值引用使用场景和意义

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

为了更好的说明问题,这里需要借助一个深拷贝的类,下面模拟实现一个简化版本的string类,类当中实现了一些基本的成员函数,并在string拷贝构造函数和赋值运算符重载函数当中打印了一条提示语句,这样当调用这两个函数时我们就能够知道.

代码如下:

namespace lzw
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
				cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;
			swap(s);
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动语义" << endl;
			swap(s);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

左值引用使用场景

在说明左值引用的短板之前,我们先来看看左值引用的场景:

左值引用做参数,防止传参时进行拷贝构造操作.
左值引用左返回值,防止返回时对返回对象进行拷贝操作.

void func1(lzw::string s)
{

}
void func2(lzw::string& s)
{

}
int main()
{
	lzw::string s("hello world");
	func1(s);//值传参
	func2(s);//左值引用传参

	s += 'x';//左值引用返回
	return 0;
}

因为我们模拟实现的时string类的拷贝构造函数当中打印了提示语句,因此运行代码后通过程序运行结果就知道,值传参时调用了string的拷贝构造函数.

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

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

左值引用的短板

左值引用虽然能避免不必要的拷贝构造操作,但左值引用并不能完全避免.

左值引用做参数,能够完全避免传参时不必要的拷贝操作.
左值引用左返回值,并不能完全避免函数返回对象时不必要的拷贝操作.

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

比如下面我们模拟实现一个int版本的to_string函数,这个to_string函数就不能使用左值引用返回,因为to_string函数返回的是一个局部变量.

代码如下:

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

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

int main()
{
	lzw::string s = lzw::to_sting(10110);
	return 0;
}

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()
{
	lzw::string s = lzw::to_sting(10110);
	return 0;
}

说明一下:

虽然to_string当中返回的局部string对象时一个左值,但由于该string对象在当前函数调用结束后就会被立即销毁,我们可以把这种即将被消耗的值叫"将亡值",比如匿名对象也可以叫"将亡值".
既然:"将亡值"马上就要被销毁了,那么还不如把它的资源转移给别人用,因此编译器在识别这种"将亡值"时会将其识别为右值,这样就可以匹配到参数类型为右值引用的移动构造函数.

编译器做的优化

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

因此再C++11标准出来之前,对于深拷贝的类来说这里就会进行两次拷贝构造,所以大部分编译器为了提高效率都会对这种情况进行优化,这种连续调用构造函数的场景通常会被优化成一次.比如:

因此按道理来说,再C++11标准出来之前这里因该调用两次拷贝构造函数,但最终被编译器优化成了一次,减少了一次无意义的深拷贝(并不是所有编译器都做了这个优化).

在C++11出来之后.编译器的这个优化仍然起到了作用:

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

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

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

编译器并没有对这种情况进行优化,因此在C++11标准出来之前,对于深拷贝的类来说这里就会存在两次深拷贝,因为深拷贝的类的赋值运算符重载函数也需要以深拷贝的方式实现.
但在深拷贝的类中引入C++11的移动构造后,这里任然需要调用一次赋值运算符重载函数进行一次深拷贝,因此深拷贝构造的类不仅要实现移动拷贝构造,还需要实现移动赋值.

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

移动赋值

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

在当前的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()
{
	lzw::string s;
	s = lzw::to_sting(10110);
	return 0;
}

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

说明一下:在实现移动赋值函数之前,该代码运行结果理论上因该调用一次拷贝构造,在调用一次原有的operator=函数,但由于原有的operator=函数实现时复用了拷贝构造函数,因此代码运行后输出的结果会多打印一次拷贝构造函数的调用,这是原有operator=函数内部调用的.

STL中的容器

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

以我们刚刚说的string类为例,这是string类增加的移动构造:

这是string类增加的移动赋值:

右值引用引用左值

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

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

move函数的定义如下:

template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

说明一下:

move函数中_Arg参数的类型不是右值引用,而是万能引用,万能引用跟右值引用的形式一样,但是右值引用需要确定的类型.
一个左值被move以后,它的资源可能就被转移给了别人,因此要谨慎使用一个被move后的左值.

右值引用的其他使用场景

右值引用版本的插入函数

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

以list容器的push_back接口为例:

右值引用版本插入函数的含义

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

int main()
{
	list<lzw::string> lt;
	lzw::string s("1111");

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

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

在C++11之前list容器的push_back接口只有一个左值引用版本,因此在push_back函数中构造结点时,这个左值值能匹配到string的拷贝构造函数进行深拷贝.
而在C++11出来之后,string类提供了移动构造函数,并且list容器的push_back接口提供了右值引用版本,此时如果传入push_back函数的string对象时一个右值,那么在push_back函数中构造结点时,这个右值就可以匹配到string的移动构造函数进行资源转移,这样就避免了深拷贝,提供了效率.
上述代码中插入第一个元素时就会匹配到push_back的左值引用版本,在push_back函数内部就会调用string的拷贝构造函数进行深拷贝,而插入后面三个元素时由于传入的是左值,因此会匹配到push_back的右值引用版本,此时在push_back函数内部就会调用string的移动拷贝构造函数进行资源转移.

完美转发

万能引用

模板中的&&不代表右值引用,而是万能引用,其既能接收左值右能接收右值.比如:

template<class T>
void PerfecForward(T&& t)
{

}

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

下面重载了四个Func函数,这四个函数的参数类型分别是左值引用,const左值引用,右值引用和const右值引用,在主函数中调用PerfecForward函数时分别传入左值,右值,const左值和const右值,在PerfecForward函数中在调用Function函数,如下:

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;
}
template<class T>
void PerfecForward(T&& t)
{
	Func(t);
}

int main()
{
	int a = 10;
	PerfecForward(a); // 左值
	PerfecForward(move(a)); //右值

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

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

但实际调用Perfectforword函数是传入左值和右值,最终匹配到了左值版本的Func函数,调用PerfectForword函数是传入const左值和const右值,最终匹配到了const左值引用版本的Function函数.
跟本原因就是,右值被引用后会导致右值被存储到特定位置,这时这个右值可以被取到地址,并且可以被修改,所以PerfectForward函数中调用Function函数时会将t识别成左值.

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

完美转发保持值得属性

要想在参数传递过程中保持其原有的属性,需要在传递参数时调用forward函数,比如:

template<class T>
void PerfecForward(T&& t)
{
	Func(forward<T>(t));
}

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

完美转发使用得场景

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

代码如下:

template<class T>
struct ListNode
{
	ListNode* _next = nullptr;
	ListNode* _prev = nullptr;
	T _data;
};
template<class T>
class List
{
	typedef ListNode<T> Node;
public:
	List()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	void PushBack(T&& x)
	{
		//Insert(_head, x);
		Insert(_head, std::forward<T>(x));
	}
	void PushFront(T&& x)
	{
		//Insert(_head->_next, x);
		Insert(_head->_next, std::forward<T>(x));
	}
	void Insert(Node* pos, T&& x)
	{
		Node* prev = pos->_prev;
		Node* newnode = new Node;
		newnode->_data = std::forward<T>(x); // 关键位置
		// prev newnode pos
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = pos;
		pos->_prev = newnode;
	}
	void Insert(Node* pos, const T& x)
	{
		Node* prev = pos->_prev;
		Node* newnode = new Node;
		newnode->_data = x; // 关键位置
		// prev newnode pos
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = pos;
		pos->_prev = newnode;
	}
private:
	Node* _head;
};

下面定义一个list对象,list容器中存储的就是之前模拟实现的string类,这里分别传入左值和右值调用不同版本的push_back.比如:

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

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

调用左值引用版本的push_back函数插入元素时,会调用string原因的operator=函数进行深拷贝,而调用右值引用版本的push_back函数插入元素时,只会调用string的移动赋值进行资源转移.

因为实现push_back函数时复用了insert函数代码,对于左值引用版本的push_back函数,在调用insert函数时只能调用左值引用版本的insert函数,而insert函数中插入一个元素时会先new一个结点,然后将对应结点赋值给该结点,因此会调用string原因的operator=函数进行深拷贝.
而对于右值引用版本的push_back函数,在调用insert函数时就可以调用右值引用版本的insert,在右值引用版本的insert函数中也会先new一个结点,然后将对于右值赋值给该结点,因此这里就会调用string的移动赋值函数进行资源的移动.
这个场景中就需要用到完美转发,否则右值引用版本的push_back接收到右值后,该右值的属性就退化了,此时在右值引用版本的push_back函数中调用insert函数,也会匹配到左值引用版本的insert函数,最终调用的还是原有的operator=函数进行深拷贝.
此外,除了在右值引用版本中的push_back函数中调用insert函数时.需要用到完美转发保持右值原有的属性之外,在有之引用版本的insert函数中用右值给新结点赋值时也需要用到完美转发,否则在赋值时也会将其识别为左值,最终调用的还是原有的operator=函数.

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

注意:代码中push_back和insert函数的参数T&&是右值引用,而不是万能引用,因为在list对象常见时这个类就被实例化了,后续调用push_back和insert函数时,参数T&&中的T已经是一个确定的类型了,而不是在调用push_back和insert函数时才进行推到的.