C++11 右值引用&完美转发

暗恋懒羊羊

于 2024-09-17 21:40:59 发布

阅读量565

点赞数 11

分类专栏： C++进阶文章标签： c++

本文链接：https://blog.csdn.net/m0_75256358/article/details/142314800

版权

C++进阶专栏收录该内容

10 篇文章 0 订阅

订阅专栏

前言

上一期介绍了C++11的基础新特性，这一期开始我们继续来介绍C++11的新特性！

1.5右值引用左值及一些更加深入的使用场景分析

一、右值引用和移动语义

传统的C++语法就有了用用的语法，而在C++11中新增了右值引用的新语法特性，所以我们从现在开始把之前学习的引用就叫做左值引用！无论左值引用还是右值引用都是给对象取别名！

1.1左值和左值引用

• 左值是一个数据的表达式(如变量名/解引用的指针)，我们可以对它进行取地址 + 赋值；

• 左值可以出现再赋值符号的左边，也可以出现在赋值符号的右边；

• const 修改的左值，不能给他赋值但是可以取地址；

• 左值引用就是给左值取别名！

// 下面的都是 左值
int a = 10;
int* pa = &a;
const int b = 3;

// 下面都是 左值引用
int& ra = a;
int*& rpa = pa;
const int& rb = b;
int& r = *pa;

左值可以取地址：

1.2右值和右值引用

• 右值也是一个数据的表达式(如：字面常量/表达式的返回值/函数的返回值等)；

• 右值也可以出现再赋值符号的右边，但是不能出现在左边；

• 右值不能取地址；

• 右值引用就是给右值取别名！

• 注意：右值引用本身是左值

// 右值 中的字面常量
10;
'a';
"hello";
3.14;

// 右值 中的表达式的返回值
double x = 1.1, y = 2.2;
x + y;

// 右值 中的函数返回值
fmin(x, y);

// 右值引用
int&& rr1 = 10;
char&& rr2 = 'a';
std::string&& rr3 = "hello";
double&& rr4 = 3.14;

double&& rr5 = x + y;
double&& rr6 = fmin(x, y);

右值不能取地址：

小tips：虽然右值不能取地址，但是给右值取了别名后，会导致右值被存储到特定的位置，且可以对该位置取地址！也就是说，不能对字面量 10 取地址，但是可以对他的右值引用取地址，也可以修改他的右值引用！如果不想他的右值引用被修改可以用const修饰！

10;
// cout << &10 << endl;// error
int&& rr = 10;
cout << &rr << endl;

rr += 1;
cout << rr << endl;

// 如果不想修改
const int&& r = 10;
// r += 1;// error

当然右值引用的主要作用当然不是这个，了解有这个特性即可！

右值引用本身是左值：

要理解这个点，只能等把右值的使用场景和优势，介绍清楚才可以理解！

1.3左值引用vs右值引用

左值引用总结：

1、左值引用可以引用左值，不能引用右值

2、const 左值引用可以引用左值，也可以引用右值

关于第二点我们呢以前就介绍过，比如果临时对象具有常性，可以用const 引用，引用它！

// 左值引用只能引用左值，不能引用右值
int a = 10;
int& ra = a;
// int& ra2 = 10;// error

// const 左值引用既可以引用左值，也可以引用右值
const int& ra3 = 10;
const int& ra3 = a;

右值引用总结：

1、右值引用只能引用右值

2、右值引用可以引用 move 后的左值

// 右值引用只能引用右值
int&& r1 = 10;
int a = 10;
//int&& rr1 = a;// error

// 右值引用可以引用move后的左值
int&& r3 = std::move(a);

上面的move函数的作用很简单，就是将左值转换为右值引用！

1.4右值引用的使用场景和意义

前面刚介绍了，左值引用不仅可以引用左值，const左值引用也可以引用右值，那为什么C++11还要提出右值引用呢？要理解这个问题就得先来搞清楚左值引用的短板了！

为了方便以后的演示这里先把以前实现的string 给拷贝过来：

namespace cp
{
	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()
		{
			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
	};

	cp::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		cp::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());

		// return move(str);
		return str;
	}
}

左值引用的使用场景

做参数和返回值可以提高效率

做参数体现在：因为引用是别名嘛，在语法上不开空间！所以做参数的话就不需要拷贝了，对于内置类型不关紧要，但是如果参数是一个自定类型的对象，例如string等不是引用就要拷贝，但是如果是引用就不需要拷贝了！极大的提高了效率！

做返回值体现在：例如上面的operator+=，如果不是引用返回，就得拷贝，然后在返回！由于执行完+=外面的对象并没有销毁所以可以用引用返回，减少了一次拷贝提高了效率！

小tips：左值引用做返回值的前提是，当出了作用域那个对象还在！

void func1(cp::string s)
{}

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

int main()
{
	cp::string s1("hello world");
	func1(s1);
	func2(s1); // 这里体现的就是 左值引用做参数的场景

	// string operator+=(char ch) 传值返回存在深拷贝
	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率

	return 0;
}

左值引用的缺陷

当函数的返回值是一个局部的变量，除了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：上面的to_string，这里返回至少是做一次拷贝构造（深拷贝），有一些老的编译器可能走两次，例如VS2013！

第一个拷贝构造是to_string的str的构造，然后是临时对象的拷贝构造，最后一个构造是因为拷贝构造的内部走的是现代写法，即调用了构造！ 我的这个vs2019比较新，优化成了1次深拷贝。我当前的电脑没有vs2013，如果你有的话可自行验证！

为了解决上述的值返回造成深拷贝的问题，C++11引入了右值引用和移动语义！

在cp::string中增加移动构造，移动构造本质就是将参数右值的资源转移过来，占为己有，那么就不用做深拷贝了，所以它叫做移动构造，就是转移别人的资源来构造自己！

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

一开始的那个构造是to_string内部的str的构造！

当然不仅有移动构造，还有移动赋值！

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

其实这里引入了右值引用之后，在to_string的那里str被编译器给move成了右值引用！当然你也可以自己手动的move效果一样！

1.5右值引用左值及一些更加深入的使用场景分析

按照语法，右值引用只能引用右值，但是右值引用一定不能引用左值嘛？由于，有些场景下，可能站的需要右值取引用左值实现移动语义。当需要右值引用，引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()；位于<utility> 头文件中，该函数的名字具有迷惑性，他并不是搬移任何的东西，唯一的功能就是将一个左值强制转为右值引用，然后实现移动语义！

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
 return ((typename remove_reference<_Ty>::type&&)_Arg);
}

cp::string s1("hello world");
cp::string s2(s1);// 拷贝构造

cp::string s3(std::move(s1));// move之后就是走的移动构造

第一次构造是s1的，下来是s1拷贝给s2的拷贝构造，拷贝构造内部是现代写法所以有第三个构造，最后一个就是s3的移动构造！

当然C++11不仅引入了右值引用，而且将他也增加到了STL中，例如：

这里不在一一介绍了！

• 理解右值引用本身是左值

右值引用的本质是为了解决自定义类型的值返回的问题，而你想将局部变量/对象返回的资源做转移，就必须得接受他，也就是你得可以修改，不然无法写入地址，也就无法转移了！所以，他这里设计其实可能是为了语法自洽！

二、完美转发

2.1万能引用

模板中的&&是万能引用，不是右值引用；他既可以接受左值又可以接受右值！他会根据接受的参数确定时左值还是右值！

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

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}

这个例子中的T&&就是万能引用！此时我们可以，试一下，是不是可以既可以接受左值，又可以介绍右值：

PerfectForward(10);// 右值
int a;
PerfectForward(a);
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值

哎？这怎么都是左值呢？？其实仔细一想，就能知道，如果接受的值本身是左值，那就正常！但是接受的值是右值，不应该是右值吗？？？是的！但是前面刚说了：“右值引用本身也是一个左值”！所以这里也就不奇怪了！如果想要是调用Fun时是右值，带用右值引用的Fun该咋办呢？其实也就是一直想保持原本的属性（左值/右值），这就是下面要介绍的完美转发了~！

2.2完美转发

std::forward 完美转发在传参的过程中，保留对象的原生属性！

所以上面的问题，可以用完美转发，完美的解决：

2.3完美转发的使用场景

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这里使用右值插入的时候，你所用的每一层都需要修改！但是如果使用move的话，每一层都需要修改，维护成本高且麻烦，易出错！所以，完美转发就是这种问题的完美解决者~！

OK，好兄弟本期分享就到这里！我是cp我们下期再见！