当前位置：首页 > news >正文

C++ - 右值引用和移动拷贝

news 来源：原创 2025/5/14 6:15:38

右值引用

我们先来了解什么是左值，什么是右值：

左值和有值区分

首先，左值和右值并不是完全意味着在 "=" 左边的就是左值；在 "=" 右边的就是右值。这是不一定的。只能说，在左边的大概率是左值，右边的可能是左值，也可能是右值：

int a = 1;
int b = a;

如上述所示， a 是左值，b 也是左值。

左值的概念：

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

也就是说，可以获取地址的值，一般都是左值；

但是有一个例外，const 修饰的变量，不能对这个变量进行修改，但是可以对这个变量取地址，所以，这个变量还是左值，如下所示;

const int a = 1;
a += 1; // 编译报错

如下所示，都是左值：

// 以下的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);

上述的 10；

x+y 这个 x+y 表达式有一个返回值，这个返回值使用一个临时变量存储的，这里指的有值是这个临时变量；

还有 fmin（x , y）函数当中的右值，是函数当中传值返回的临时对象，

他们都有一个特点，都不能取地址。

如果强行取地址的话，就会被报错（必须是左值类似报错）：

在了解左右值之后，我们来看 "xxxxxx"；这个常量字符串是左值还是右值？

其实 常量字符串 是左值，就算我们如下面一种方式书写：

"xxxxxx";

其实还是右值，虽然我们不能对这个常量字符串进行修改，但是我们能取到这个字符串的地址：

const char* p = "xxxxxx";
cout << &("xxxxxx") >> endl;

按照上述的 p 这个指针的理解，我们还是可以取到这个字符串的首字符地址。所以还是左值。

同样的 &p[2] 我们取出常量字符串当中的第三个字符，还是可以取地址，说明，取出的常量字符串的第三个字符，还是左值。只是不能修改而已。

总结：可以取地址的就是左值；不能去取地址的就是右值；

左值引用和有值引用区分

引用是取别名，左值引用就是对左值取别名；右值引用就是对有值取别名。

// 左值引用
int a = 10;
int& pa = a;

// 右值引用
int&& p5 = 10;
double x = 1.1, y = 2.2;

double& r6 = x + y; // 编译报错

double&& r7 = x + y; // 编译通过

如上所示： 类型& 是左值引用；而类型&& 就是右值引用。

在上述例子当中的左值引用是没有办法给右值引用取别名的，但是如果是 const 的左值引用就可以给右值取别名：
const int& p = 10; // 编译通过
所以，在之前写模版函数的时候，我们经常这样写：
template<class T>
void func(const T& x)
{
````````
}
如果函数的参数是模版的引用的话，都是建议加上 const 修饰的，因为加上const 的话，这个模版参数既可以接收左值引用，有可以接收右值引用。

那么右值引用，是否可以引用左值呢？

答案是可以。

但是也是不能直接引用，加上 const 也不行，必须加上 move（）函数，move一下：
int a = 1;
int&& p1 = a; // 编译报错
int&& p2 = move(a);  // 编译通过
也就是说右值引用，可以引用 move 之后的左值，但是右值 move 之后，虽然在上述例子当中没有什么问题，可正常使用，但是在一些情况下会出现问题，具体看下述说明。

左值引用的价值

在函数的参数传参，和函数的返回值上，如果使用的是同类型的参数传参或者返回的话，是要构建一个临时变量来暂时存储要传入或者返回的值，然后再把临时变量，拷贝给形参，或者是用于接收函数返回值的变量。如果是内置类型就还好，但如果是自定义的类型，一个对象需要的空间不小的话，那么拷贝就会造成不小的消耗。其中的消耗有空间上的，还有，如果是深拷贝的话，可能还有动态开辟当中的空间当中的值需要赋值，这就有时间上的消耗了。

那么在上述的过程当中肯定就会发生消耗，所以，我们可以使用左值引用的方式，使得传入的是实参（本对象），就是实参本身，所以是不用进行拷贝，函数当中的形参使用就是传入实参本身。返回值也是一样，返回的是函数当中的变量。

需要注意的是：如果返回的是，作用域在函数当中的变量，那么，当函数执行结束，这个变量也就跟着销毁了，如果我们返回的是这个变量的引用的话，就会是野引用，和野指针的后果是一样。

int& func1(const int& x)
{
    return x;
}

int main()
{
    int x = 1;
    int ret = func(x);    

    return 0;
}

当然，左值引用带来很多的好处，但是也有左值引用做不到的事情：

就是上述的函数的当中的变量，无法用左值引用的方式来返回，在没有右值引用的情况下，我们只能直接传参返回，也就是要拷贝一个临时变量，然后赋值给外部的接收变量。

但是，我们知道，这样的拷贝返回代价不小，但是左值引用又不能解决，因为函数当中的变量已经销毁了，就算我们拿到这个变量的地址，那么其中的数据也是非法的，而且，这个变量（对象）在销毁的时候会调用析构函数，那么我们拿到的这个块空间也是非法的。而且，如果我们在外部用一个变量来接收的话，那么按道理，黑丝要拷贝两次的：

第一次是在函数栈帧销毁之前，就会要拷贝的对象，拷贝到临时对象当中，然后再把临时对象拷贝给我们接收的变量，但是有些编译器会对此处进行优化，直接就拿函数当中要返回的对象直接对外部接受的变量进行拷贝，但是不是所有的编译器都会这样做的。

而且上述的优化是在一句语句当中的连续的拷贝构造，如下所示：

string func()
{
    string str;
    cin << str;
    
    return str;
}

int main()
{
    string ret = func();
    retrun 0;
}

如果拷贝构造不是连续的，就不能进行优化了：

string func()
{
    string str;
    cin << str;
    
    return str;
}

int main()
{
    string ret;
    // ·······
    // 一些操作
    ret = func();

    retrun 0;
}

上述情况就不能进行优化了。

左/右值引用两者构成函数重载

如下函数所示，是构成函数重载的：

void func(int& x)
{
	cout << "void func(int& x)" << endl;
}

void func(int&& x)
{
	cout << "void func(inr&& x)" << endl;
}

int main()
{
	int x = 1;
	int y = 2;
	func(x);   // 左值引用

	func(x + y); // 右值引用

	return 0;
}

输出：

void func(int& x)
void func(int&& x)

发现重载关系已经匹配上了。

我们上述也说过，const 的左值引用也是可以接收右值的，那么 const 的左值引用和右值引用其实也是可以构成函数重载的：

void func(const int& x)
{
	cout << "void func(int& x)" << endl;
}

void func(int&& x)
{
	cout << "void func(inr&& x)" << endl;
}

int main()
{
	int x = 1;
	int y = 2;
	func(x);   // 左值引用

	func(x + y); // 右值引用

	return 0;
}

输出：

void func(int&& x)
void func(int& x)

发现，分别传入左右值引用，都是可以分别用重载函数接受的。

因为 const 的左值引用，既可以接收左值引用，又可以接收右值引用，如果上述例子，如果没有右值引用重载函数，也是可以接收的：

void func(const int& x)
{
	cout << "void func(int& x)" << endl;
}

int main()
{
	int x = 1;
	int y = 2;
	func(x);   // 左值引用

	func(x + y); // 右值引用

	return 0;
}

输出：

void func(int& x)
void func(int& x)

而发生上述的 const 的左值引用和右值引用 调用两个重载函数的情况，就是编译器在匹配重载函数时候的选择，如果在重载函数当中有多个函数都可以接收当前传入的参数，那么，编译器会选择一个最适合的重载函数进行调用，也就是实参和形参的参数最符合的重载函数。

有右值引用的版本就会走跟匹配的右值引用的版本。

右值引用的价值 - 移动拷贝 - 移动构造

我们看到，上述在函数当中返回一个对象，那么我们不能使用左值引用，不然会发生野引用；如果不使用引用返回，直接还用传值返回的话，我们肯定是要用一个变量来接收的，那么在函数返回值之前，也就是在函数栈帧销毁之前，会先深拷贝（如果是需要深拷贝的对象）一份临时对象，然后在把临时对象拷贝给我们用于接收的变量上，相当与是要深拷贝两次。

而且，我们发现：
内置类型的右值，就是纯右值；而自定义类型的右值，是将亡值。

如上述所示，func（）返回的是一个临时变量（对象），这个临时对象的作用域和匿名对象是一样的，出了函数，临时对象就会销毁了。所以，func（）函数的返回值本质上就是一个右值当中的将亡值，因为 func（）的返回对象只有 ret = func(); 这一行，在下一行，这个临时对象就会被销毁。

在内置类型当中使用的操作符本质上是调用运算符重载函数，比如 string 当中的对象 s1 + s2 ，那么两个 string 类型的对象相加，实际上是调用了 operator+() 这个函数，还有像 to_string 一样也是用调用函数，那么，这两种方式调用函数，使用传值返回都是会构造一个临时对象返回。

上述说明了左/右值引用作为参数的函数，可以构成函数重载。

那么对于 operator=（）这个函数，我们就可以写一个右值版本的，在这个版本当中，使用现代写法，既然 func（）当中的临时变量出了函数是要销毁的，那么，就像直接使用 swap（）函数把临时对象当中的成员信息都交换给 ret，那么在临时对象当中的成员数据就复制给 ret，那么在临时变量被编译器销毁的时候，就把原本在 ret 当中的成员和动态开辟的空降给析构了。

而 ret 也成功的拿到了临时变量当中的信息，没有进行第二次的深拷贝操作。

我们把上述的这种拷贝方式成为移动拷贝。

例如在 string 当中的 operator=（）函数实现：

string& operator=(string&& s)
{
	swap(s);
	return *this;
}

那么在外部使用的时候：

string ret = func();

因为 func（）的返回值是右值，所以就会调用上述，函数参数类型是右值的函数，就使用现在写法，直接把 s 当中的成员信息拷贝给当前对象（其中肯定有 string 当中字符串的指针，直接交换指针（浅拷贝）即可，那么交换之后，之前需要拷贝的字符串（s）当中的字符就由当前对象的字符串指针所维护了，接着 s 出了自己的作用域，就会把之前在 ret 当中的空间析构掉）

右值引用不是像左值引用一样，直接是这个变量（对象）的别名，而是该拷贝的还是得拷贝，但是，向上述一样的多次拷贝就不用了，拷贝一次就够用了，不用再进行多余的拷贝了。

上述提到现代写法，其实还有传统写法，两种方法在在 string 当中其实都差不多，但是在上述右值引用当中就有大作用，具体可以看下篇对 string 的 operator=（）重载运用符函数的讲解：
C++-string类的模拟实现_chihiro1122的博客-CSDN博客

像上述的右值引用加现代写法（也就是移动拷贝），不仅仅可以用于 operator=（）重载运算符函数，还可以用于构造函数，此时就叫做移动构造了

我们还可以写一个本对象类型的右值引用的重载构造函数，再去其中也可以使用现代写法（例如string 当中的本对象类型的右值引用的重载构造函数）：

string (string&& s)
    :_str(nullptr)
{
    swap(s);
}

上述也是使用 swap （）函数交换了 s 对象和当前对象当中的成员数据。

像上述的当中的本对象类型的右值引用的重载构造函数（拷贝函数）是适用于下面这种情况的：

如果上述的代码编译器不进行优化， func（）函数当中的 str 会先深拷贝一个临时对象出来，因为重载了 operator=（）函数，所以赋值给 ret1 是一个浅拷贝。那么，现在这种情况就是和最开始，编译器优化之后的结果了。

但是，如果编译器进行优化的（编译器的第一步优化），那么在上述两步就会合成一步，首先，合二为一的出来的一步，肯定不会是移动构造的那一步，而是深拷贝（使用拷贝构造函数）的那一步。因为 str 又是一个左值，所以我们在构造函数当中写的一定构造不起作用。

但是，上述场景太多了，编译器又对此进行优化（编译器第二步优化），从上述 func（）函数来看，str 虽然是左值，但是他是符合将亡值的特征的，也就是出了 bit:string ret1 = func() 这个行代码之后，str 就会被析构。编译器会把 str 识别成 右值当中的将亡值。

所以，这个地方，在实现了上述 operator=（）和构造函数的右值重载函数之后，就只会调用一次移动拷贝（在函数栈帧销毁之前，就会做拷贝）：

在这里的话，本来是要拷贝两次的，但是现在一次都不用拷贝了，直接把 str 浅拷贝给了 ret1。

注意：在外部函数如上述的 func 函数，返回值不能是 string&，因为是string 才能达到上述的优化效果，如果是 string& 就是左值引用了，返回 string& 就不会做上述的优化的事情，因为返回的引用，只有传值返回才有上述的优化。str 会正常销毁，销毁之后返回的就是野指针了。

注意：上述的第二次优化，是因为我们函数返回的类型是传值返回，才有把 str 从原本的左值是被成右值，这一步优化。如果不进行第二次优化，是临时对象做的返回值。

（上述的第二次优化是所有的编译器都支持的，因为是C++对编译器实现的规定，如果编译器不这样进行优化的，右值引用带来的优化相当于砍掉了半条腿）

可以理解为，是编译器在这个地方做的特殊处理。

还有就是之前，编译器第一次优化都无法实现的，在实现 operator=（）的右值引用函数之后，就被右值引用所优化了：

在 C++98 时候，没有右值引用，就不能使用上述方式来优化，直接传值返回的话代价就太大了，所以，一般是使用函数传参，传入引用的方式来解决的：

写过 C 的力扣题的都知道这样写是比较麻烦的。

move（）函数的浅谈

由之前对右值引用引用左值，使用用move（）函数来实现的：

string ret = "xxxxxxxxxx";
string&& p1 = move(ret);

但是下述方式不能用到右值引用：

string ret1("xxxxxxxxxxxx");
move(ret1);
string copy1 = ret1;

按照之前对 string当中右值引用参数的 operator=（）运算符重载函数的介绍，那么上述如果 ret1被 move 修改为右值引用的话，就会调用右值引用参数的 operator=（）运算符重载函数。那么 copy1 就会继承 ret1 当中的各个数据，空间等等属性，而 ret1 就会被销毁。

但是，结果是并没有，就是原本的拷贝一份的 operator=（）运算符重载函数。ret1 并没有销毁。

但是下述代码，copy1 就会继承 ret1 当中的各个数据，空间等等属性，而 ret1 就会被销毁：

string ret1("xxxxxxxxxxxx");
string copy1 = move(ret1);

也就是说，move（）函数，不会修改到 ret1，也就是传入的参数，它只是返回一个该参数的引用或者是指针，这个就是右值了，编译器就会识别为右值，调用右值引用参数的 operator=（）运算符重载函数。

右值引用使用场景

从上述例子我么可以发现右值引用基本上是用于自定义类型的拷贝优化，对于内置类型，右值引用的优化不大，因为内置类型最大就是才几个字节，而自定义类型可能会很大，比如在位图和布隆过滤器当中的存储就可以达到几个 G。

总之就是内置类型，或者是体积都比较小的自定义类型，是没必要使用右值引用来优化的；比如 Date 日期类，其中就只有几个变量比如 _year _day _ month ，除了这些变量，没有必要在动态开辟空间。那么对于 _year _day _ month ，我使用右值引用就是交换值，那么使用拷贝构造函数也是一样的值拷贝，那么右值引用写来有什么意义呢？两这之前没有什么区别。

所以，对于浅拷贝的类，移动构造不要实现，没有什么需要转移的资源（比如堆空间），直接拷贝就行。比如其中有 10 个 int 类型的成员变量，就只是 40 个字节，直接拷贝就行了。传值返回代价也不大，所以右值引用的构造函数也不用写。

右值引用主要使用在深拷贝的类当中，也就是需要深拷贝的对象，那么才需要右值引用来提升效率。

还有一个场景，我们在上篇博客当中说过了，在 C++11 之后就把 STL 容器当中的 push_back 函数给升级了，支持了右值引用的版本，所以，当我们在使用容器嵌套容器的时候，就可以用move（）函数强制右值引用，这样就可以使用移动构造，优化效率：

就是在链表 Node 结点的构造函数当中，有对 val 的初始化，此时的 val 的类型是 string 类型，此时就有了类的深拷贝了，如果不使用移动拷贝，就会调用string的拷贝构造函数，就会进行一次深拷贝，所以，此时就有了右值引用版本的 push_back （）不用拷贝构造，直接把 s2 的空间等等属性给到Node 结点当中：