左值引用和右值引用

最新推荐文章于 2024-07-04 16:16:29 发布

奇点 ♡

最新推荐文章于 2024-07-04 16:16:29 发布

阅读量807

点赞数 21

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

本文链接：https://blog.csdn.net/2302_81250321/article/details/139493740

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1.左值引用和右值引用概念

左值引用

什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋
值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左
值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

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 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);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

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

快速判断左值和右值：看看能否取地址，能的是左值，不能是右值

左值引用总结：
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

int main()
{
   // 左值引用只能引用左值，不能引用右值。
   int a = 10;
   int& ra1 = a;   // ra为a的别名
   //int& ra2 = 10;   // 编译失败，因为10是右值
   // const左值引用既可引用左值，也可引用右值。
   const int& ra3 = 10;
   const int& ra4 = a;
   return 0;
}

右值引用总结：
1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值，move是库里提供的函数，move（左值）使得有右值属性。

int main()
{
// 右值引用只能右值，不能引用左值。
int&& r1 = 10;


// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a;
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}

2.右值引用的场景

左值引用的场景是不是用过很多啦，比如函数传值，传引用，函数返回，返引用

右值引用有什么场景呢？

移动构造

先看下面写的string

namespace qd
{
	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 s = *this;
			s.push_back(ch);
			return s;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

那我们自己写了一个移动构造呢？

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

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

假如你是用move（左值）来构造，会出现什么现象呢？

函数传值返回

函数返回值，如果那个值函数销毁之后还存在就可以传引用返回，这就是左值引用的经典用法，但是假如这个值函数销毁之后它也销毁了，那就要拷贝，不能传引用返回了，但是怎么减少拷贝，使效率变高呢？

用以下函数来分析

namespace dq
{
	qd::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		qd::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 str;
	}
}

移动赋值

移动赋值也一样，当你把右值（将亡值）赋值给一个变量的时候，就把它的资源窃取过来，减少拷贝

// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动赋值" << endl;
	swap(s);
	return *this;
}
int main()
{
	qd::string ret1;
	ret1 = qd::to_string(1234);
	return 0;
}

3.完美转发

模板中的万能引用

以下程序你觉得输出结果是什么？

void Fun(int& x) 
{ 
	cout << "左值引用" << endl;
}
void Fun(int&& x) 
{
	cout << "右值引用" << endl; 
}
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10); // 右值
	return 0;
}

引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用完美转发

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

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(std::forward<T>(t));
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a);// 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);// const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}