【C++篇】C++11：右值引用与移动语义

我想吃余

发布于 2025-08-11 08:24:39

3520

一、左值引用和右值引用

什么是左值？什么是右值？

左值：可以获取它的地址+可以对它赋值（修改）定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值既可以出现在=的左边，也可以出现在右边
右值：右值不能取地址，也不能赋值（修改）右值可以出现在=的右边，但是不能出现出现在赋值符号的左边

int fmin(int a, int b)
{
	return a < b ? a : b;
}

int main()
{
	// 以下都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	"xxxxx";//注意常量字符串也是左值，因为它可以被取地址，
	const char* p = "xxxxx";
	p[2];//字符串字面值具有数组类型，是左值（尽管它是不可修改的左值）。
	
	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);//函数的返回值是右值

	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;

	return 0;
}

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

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

对左值的引用就是左值引用，给左值取别名，定义方式：type&
右值引用就是对右值的引用，给右值取别名，定义方式：type&&

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

需要注意的是：右值是不能取地址的，但给右值取别名后，会导致右值被存储到特定的位置，且可以取到该位置的地址，并且还可以去修改它，如果不想让被引用的右值被修改，可以用const修饰右值引用。

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后的左值

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

二、右值引用使用场景和意义

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

代码如下：

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

代码说明：由于operator=()用的是现代写法（调用拷贝构造），因此调用他会打印两次深拷贝信息，这里我们要视为一次深拷贝，

场景1：自定义类型中深拷贝的类，必须传值返回的场景

回顾左值引用使用场景和意义

左值引用使用场景：

做函数的参数
做函数的返回值价值：减少拷贝构造，提升效率。

void func1(string s)
{}

void func2(const string& s)
{}

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

左值引用的短板

左值引用虽然能避免不必要的拷贝操作，但左值引用并不能完全避免：当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。

string func()
{
	string str("woxiangchiyu");
	//cin >> str;
	//....
	
	return str;
}

int main()
{
	string ret1 = func();
	
	return 0;
}

无奈只能含泪拷贝构造两次，如果拷贝对象较大，将是一笔不小的开销。

图解说明：因为operator=()用的是现代写法（调用拷贝构造），所以这里暂且将其与拷贝构造归为一类。

C++11新增的右值引用就是为了解决左值引用的短板的，但并不是简单的将右值引用作为函数的返回值。

右值引用和移动语义解决左值引用的短板

移动构造： 移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己，并将自己原本的无用资源再交给别人，顺便让别人再帮忙释放自己的资源。说白了，就是和目标对象进行资源交换

在当前的string类中增加一个移动构造函数，该函数要做的就是调用swap函数将传入右值的资源窃取过来，为了能够更好的得知移动构造函数是否被调用，可以在该函数当中打印一条提示语句。

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

//拷贝构造函数
string(const string& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	cout << "string(const string& s) -- 深拷贝" << endl;

	string tmp(s._str);
	swap(tmp); 
}

移动构造VS拷贝构造

在没有增加移动构造之前，由于拷贝构造采用的是const左值引用接收参数，因此无论拷贝构造对象时传入的是左值还是右值，都会调用拷贝构造函数。
增加移动构造之后，由于移动构造采用的是右值引用接收参数，因此如果拷贝构造对象时传入的是右值，那么就会调用移动构造函数（匹配原则）。
string的拷贝构造函数做的是深拷贝，而移动构造函数是调用swap函数进行资源的转移，本质上是浅拷贝。因此，移动构造比拷贝构造的代价低得多。

移动赋值：与移动构造是同理的，这里平移过来理解即可

在该函数当中打印一条提示语句。

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

//赋值运算符重载（现代写法）
string& operator=(const string& s)
{
	cout << "string& operator=(const string& s) -- 深拷贝" << endl;

	string tmp(s); 
	swap(tmp); 
	return *this; 
}

我们将右值分为两类：

内置类型的右值，称作纯右值
自定义类型的右值，称作将亡值

当函数返回值是一个将亡值时，编译器就会调用移动拷贝
当函数返回值是一个左值时，编译器就会调用深拷贝

比如：

我们来看看运行结果：需要注意的是，现在C++拥有RVO优化机制：。

当函数返回一个局部对象时（如 func() 中的 str），编译器会直接在调用方的内存位置构造这个对象（即 ret1），跳过拷贝/移动构造。
在 main() 中：

string ret1 = func();  // 直接构造 ret1，无额外拷贝

编译器将 ret1 的地址传递给 func()，让 func() 在其内部直接将 str 构造到 ret1 的内存中，避免临时对象的创建和拷贝。

但是我们可以显式使用 std::move，阻止 RVO，去调用我们的拷贝函数：

string func()
{
	string str("woxiangchiyu");
	//cin >> str;
	//....

	return move(str);//显式使用 std::move
}

小插曲：这个RVO机制属实让我有点绷不住了🤮，因为我学习的视频是一两年前的，那时应该是还没有RVO，我照例运行出来发现是空的，然后我就找错，代码看了两三遍，我终于开始怀疑是编译器从中做鬼，然后一查果然是！不得不感叹一下，如今编译器优化程度真是有点逆天了。

可以看到，运行结果与我们图中分析的不太一样。其实是编译器优化后导致的结果。

编译器优化机制

我们知道，对于连续拷贝时，编译器会优化为只拷贝一次

右值对象构造，只有拷⻉构造，没有移动构造的场景：

运行截图：

但是，当创建对象与赋值分离时：

string func()
{
	string str("woxiangchiyu");
	//cin >> str;
	//....
	
	return str;
}

int main()
{
	string ret1;
	ret1 = func();
	
	return 0;
}

编译器无法优化，因为拷贝不是连续的了。运行截图：

右值对象构造，有拷贝构造，也有移动构造的场景

编译器优化了两处：

连续构造/拷贝构造，合二为一
将str识别为右值（将亡值）尽管str在函数中为左值，当却是一个将亡值，因此将其视为右值合情合理。

当创建对象与赋值分离时：编译器也能优化：将str识别为右值（将亡值）但无法优化连续拷贝/构造问题。

运行截图：

对于自定义类型中浅拷贝的类，必须传值返回的场景，有必要去实现移动拷贝吗？

明确右值引用的核心价值：相对于左值引用，进一步减少拷贝，弥补左值引用没有解决的场景。
对于浅拷贝的类，比如Date类，它的成员变量均为内置类型，拷贝构造的代价不大，只是对成员变量赋值。
如若非要实现移动拷贝，交换内置类型的资源的本质也是对成员变量赋值，和拷贝构造没有任何效率提升，那我们又何苦白费力气的去添加移动拷贝呢？

因此，浅拷贝的类不需要实现移动构造，传值返回的拷贝代价也并不大。

场景2：对于容器的插入接口，插入对象是右值的场景

我们知道，C++11标准出来之后，STL容器插入接口函数也增加了右值引用版本。

添加右值引用版本插入函数的意义

以list容器的push_back为例：

我们知道，list的push_back接口的实现逻辑是：先构造一个结点，然后再将该结点插入到底层的双链表当中。

//左值引用版本
void push_back(const string& val)
{
	Node* newnode = new Node(val);
	//…………
}

//右值引用版本
void push_back(string&& val)
{
	//这里的forward<T>(val)是完美转发
	//目的是使val为右值，至于为什么val会为左值，后文完美转发会详细讲解
	Node* newnode = new Node(forward<T>(val));
	//…………
}

我们插入左值和右值：

int main()
{
	list<string> lt;
	string s("woxiangchiyu");

	lt.push_back(s);//插入左值

	//插入右值
	lt.push_back(move(s));
	lt.push_back("111111");
	lt.push_back(string("222222"));//匿名对象

	return 0;
}

插入左值，在push_back函数中构造结点时，这个左值只能匹配到string的拷贝构造函数进行深拷贝。
插入右值，在push_back函数中构造结点时，这个右值就可以匹配到string的移动构造函数进行资源的转移，这样就避免了深拷贝，提高了效率。注意：前提是string类提供了移动构造函数，并且list容器的push_back接口提供了右值引用版本

函数调用图解：

运行结果：

总结：容器的插入接口，如果对象是右值，可以利用移动构造转移资源给数据结构的对象，也可以减少拷贝构造，提升效率。

三、完美转发

万能引用

模板中的&&不是右值引用，而是万能引用，既可以接收左值，又可以接收右值。

template<class T>
void PerfectForward(T&& t)
{
	//...
}

实参为左值，就是左值引用（又称引用折叠，意指两个&折叠一下，变成一个&）
实参为右值，就是右值引用

完美转发保持值的属性

看下面一段代码：

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

运行结果截图：

原来，为了使得右值的资源能够被转移，编译器不得不将右值引用的属性识别为左值。

但是如果需要引用的属性不发生变化：右值引用就是右值、左值引用就是左值。有什么解决方案呢？

完美转发功能正在于此，在需要保持原本属性的引用x上使用：forward<T>(x)即可如下：

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

运行结果：