左值引用与右值引用

zwj9367

已于 2025-02-19 20:02:21 修改

阅读量1k

点赞数 27

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

于 2025-02-19 19:56:41 首次发布

本文链接：https://blog.youkuaiyun.com/zwj9367/article/details/145733954

版权

C++11相关专栏收录该内容

8 篇文章

订阅专栏

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址，可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时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;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说：右值引用右值后，必然会变为左值属性，因为只有左值才可以被修改，能被修改的对象才可以进行资源指针指向的改变，才能将资源换出/换入。

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

左值引用和右值引用的比较

左值引用总结

左值引用只能引用左值，不能引用右值
但是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;
}

右值引用总结

右值引用只能右值，不能引用左值
但是右值引用可以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;
}

左值引用的使用场景和短板

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

void func1(bit::string s)
{}
 
void func2(const bit::string& s)
{}
 
int main()
{
     bit::string s1("hello world");
     // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
     func1(s1);
     func2(s1);
     // string operator+=(char ch) 传值返回存在深拷贝
     // string& operator+=(char ch) 传左值引用没有拷贝提高了效率
     s1 += '!';
     return 0;
}

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value) 函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)

右值引用的移动语义与效率提升

右值引用的效率提升是通过对资源的剽窃来实现的，比如说一个由动态开辟的内存的对象，生命周期马上结束，这个时候我们的函数需要返回这个对象，在C++11到来前，通常是将这个对象做一次拷贝，而后将这个拷贝的对象的值在拷贝给接收返回值的变量（此处默认，不开启编译器优化功能）。假如我们在对这个局部对象返回的时候，可以直接将需要返回对象的资源指向指针重新定位到该函数外的对象，不让编译器去两次拷贝赋值，是不是就极大的提升了效率。而右值应用很大程度上是依靠移动语义来实现效率的提升的，也就是说移动语义是效率提升的具体实现。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
 
namespace test
{
	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)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			std::cout << "string(const string& s) -- 拷贝构造" << std::endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			std::cout << "string& operator=(string s) -- 赋值重载" << std::endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string && s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			std::cout << "string(string&& s) -- 移动构造" << std::endl;
			swap(s);
		}
		// 移动赋值
		string& operator=(string && s)
		{
			std::cout << "string& operator=(string&& s) -- 移动赋值" << std::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
	};
}
 
int main()
{
	test::string a = "111";
 
	test::string b = a;
	test::string c;
	c = a;
 
	test::string d(std::move(a));
	test::string e;
	e = "111";
	
	return 0;
}

我们自己定义一个string类型（类似C++STL库中的string），其他的类成员函数暂且不看，先将目光聚焦在这样几个函数：void swap(string& s)、string(string&& s)、string& operator=(string&& s)。我们按照顺序暂且依次称呼这三个函数为swap函数，移动构造函数、移动赋值函数，通过上述代码不难看出swap函数的实现逻辑是：将传入对象的资源换出到this指针指向的对象中，这样就是实现来对应资源的转移。需要注意到是，如果将资源换入到当前对象中，被换出资源的对象会持有当前对象的数据，也就是说被换出资源的对象会析构换入对象的资源，所以对于移动构造我们应该对指针类型都应初始化为空指针类型，来保证换出资源对象的释放资源不会出错。

再观察移动构造和移动赋值函数，二者在实现的时候，都是使用右值引用类型作为参数输入，在具体函数实现的过程中封装了swap函数，这其实也就解释了移动语义的工作原理，是通过资源交换来实现效率提升的。运行上述代码进行测试有如下结果：

int main()
{
    // string(const string& s) -- 拷贝构造
	test::string a = "111";

    // string& operator=(string s) -- 赋值重载
	test::string b = a;
	test::string c;
    // string(const string& s) -- 拷贝构造
	c = a;

    // string(string&& s) -- 移动构造
	test::string d(std::move(a));
	test::string e;
    // string& operator=(string&& s) -- 移动赋值
	e = "111";

	return 0;
}

右值引用右值后变成左值的必要性

using namespace std;

void func1_(int&& element1_)
{
    cout << "右值引用" << endl;
}

void func1_(int& element1_)
{
    cout << "左值引用" << endl;
}

void func1(int&& element1)
{
    func1_(element1);
}

int main()
{
    int a = 0;
    func1(0);
    return 0;
}

程序的运行结果为“左值引用”，这里的结论是：右值引用右值后，必然会变为左值属性，因为只有左值才可以被修改，能被修改的对象才可以进行资源指针指向的改变，才能将资源换出/换入。

引用折叠（万能引用）

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

完美转发

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

// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
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;
}