c++中的右值解析

最新推荐文章于 2025-10-13 06:05:56 发布

原创最新推荐文章于 2025-10-13 06:05:56 发布 · 3.1k 阅读

17 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++ #开发语言

本文详细介绍了C++中的右值和右值引用，包括它们与左值的区别，右值引用的本质及应用场景。重点讨论了右值引用如何指向左值，并通过实例展示了右值引用在避免拷贝和提升效率上的作用，特别是在自定义类型如Mystring中的移动构造函数和转移赋值操作符的应用。

1.理解右值是什么（和左值的区别）

简单点说，右值就是在等号右边的值。

左值可以取地址、位于等号左边；而右值没法取地址，位于等号右边。

int a = 5;
int &ref_a = a; // 左值引用指向左值，编译通过
int &ref_a = 5; // 左值引用指向了右值，会编译失败

2.什么是右值引用

引用本质是别名，可以通过引用修改变量的值，传参时传引用可以避免拷贝，其实现原理和指针类似。个人认为，引用出现的本意是为了降低C语言指针的使用难度，但现在指针+左右值引用共同存在，反而大大增加了学习和理解成本

2.1左值引用

左值引用大家都很熟悉，能指向左值，不能指向右值的就是左值引用：

int a = 5;
int &ref_a = a; // 左值引用指向左值，编译通过
int &ref_a = 5; // 左值引用指向了右值，会编译失败

引用是变量的别名，由于右值没有地址，没法被修改，所以左值引用无法指向右值。

但是，const左值引用是可以指向右值的：

const int &ref_a = 5;  // 编译通过

const左值引用不会修改指向值，因此可以指向右值，这也是为什么要使用const &作为函数参数的原因之一，如std::vector的push_back：

void push_back (const value_type& val);

如果没有const，vec.push_back(5)这样的代码就无法编译通过了。

2.2 右值引用

再看下右值引用，右值引用的标志是&&，顾名思义，右值引用专门为右值而生，可以指向右值，不能指向左值：

int &&ref_a_right = 5; // ok
 
int a = 5;
int &&ref_a_left = a; // 编译不过，右值引用不可以指向左值
 
ref_a_right = 6; // 右值引用的用途：可以修改右值

2.3 对左右值引用本质的讨论

下边的论述比较复杂，也是本文的核心，对理解这些概念非常重要。

2.3.1 右值引用有办法指向左值吗？

有办法，std::move：

int a = 5; // a是个左值
int &ref_a_left = a; // 左值引用指向左值
int &&ref_a_right = std::move(a); // 通过std::move将左值转化为右值，可以被右值引用指向
 
cout << a; // 打印结果：5

3.应用场景

3.1 如下实现一个Mystring类

#include <iostream>
#include <vector>
#include <string.h>
#include <strings.h>
using namespace std;

class MyString {
public:
    MyString(){
        m_data = NULL;
        m_len = 0;
    }

    MyString(const char* s){
        m_len = strlen(s);
        init_data(s);
        cout << "构造函数" << s << endl;
    }

    MyString(const MyString &str){
        m_len = str.m_len;
        init_data(str.m_data);
        cout << "拷贝" << str.m_data << endl;
    }

    //
    MyString& operator=(const MyString &str){
        if (this != &str) {
            this->m_len = str.m_len;
            init_data(str.m_data);
        }
        cout << "赋值" << str.m_data << endl;
        return *this;
    }

    ~MyString(){
        if (m_data != NULL) {
            cout << "析构函数" << endl;
            free(m_data);
        }
    }

private:
    void init_data(const char *s){
        m_data = new char [m_len + 1];
        memcpy(m_data,s,m_len);
        m_data[m_len] = '\0';
    }

    char* m_data;
    size_t m_len;
};

测试函数：

void test(){
    vector<MyString> vec;
    MyString a;
    a = MyString("hello");
    vec.push_back(MyString("world"));
}

输出：

构造函数hello
赋值hello
析构函数
构造函数world
拷贝world
析构函数
析构函数
析构函数

我们可以看到，因为const的修饰，往重载=传入右值时也能通过编译，但会被深拷贝。

总共执行了2次拷贝，MyString("Hello")和MyString("World")都是临时对象，临时对象被使用完之后会被立即析构，在析构函数中free掉申请的内存资源。
如果能够直接使用临时对象已经申请的资源，并在其析构函数中取消对资源的释放，这样既能节省资源，有能节省资源申请和释放的时间。这正是定义移动语义的目的。

通过加入定义移动构造函数和转移赋值操作符重载来实现右值引用（即复用临时对象）：

#include <iostream>
#include <vector>
#include <string.h>
#include <strings.h>
using namespace std;

class MyString {
public:
    MyString(){
        m_data = NULL;
        m_len = 0;
    }

    MyString(const char* s){
        m_len = strlen(s);
        init_data(s);
        cout << "构造函数" << s << endl;
    }

    MyString(const MyString &str){
        m_len = str.m_len;
        init_data(str.m_data);
        cout << "拷贝" << str.m_data << endl;
    }

    MyString(MyString &&str){
        cout << "右值拷贝（使用原有资源）" << str.m_data << endl;
        m_len = str.m_len;
        init_data(str.m_data);
        str.m_len = 0;
        //防止在析构函数中释放内存
        str.m_data = NULL;
    }

    //先拷贝，再赋值
    MyString& operator=(const MyString &str){
        if (this != &str) {
            this->m_len = str.m_len;
            init_data(str.m_data);
        }
        cout << "赋值" << str.m_data << endl;
        return *this;
    }


    MyString& operator=(MyString && str){

        cout << "右引用赋值（使用原有资源）" << str.m_data << endl;
        if (this != &str) {
            this->m_len = str.m_len;
            this->m_data = str.m_data;
            //防止在析构函数中释放内存
            str.m_data = NULL;
            str.m_len = 0;
        }
        return *this;
    }

    ~MyString(){
        if (m_data != NULL) {
            cout << "析构函数" << endl;
            free(m_data);
        }
    }

private:
    void init_data(const char *s){
        m_data = new char [m_len + 1];
        memcpy(m_data,s,m_len);
        m_data[m_len] = '\0';
    }

    char* m_data;
    size_t m_len;
};

void test(){
    vector<MyString> vec;
    MyString a;
    a = MyString("hello");
    vec.push_back(MyString("world"));
}

构造函数hello
右引用赋值（使用原有资源）hello
构造函数world
右值拷贝（使用原有资源）world
析构函数
析构函数

3.2 结合std::move 和右值引用，可以避免不必要的拷贝。swap的定义变为：

namespace MyT {
    template<class T>
    void swap(T &a, T &b) {
        T tmp(std::move(a));
        a = std::move(b);
        b = std::move(tmp);
    }
}

void test(){
    MyString a("hello");
    MyString b("world");
    MyT::swap<MyString>(a, b);
}

构造函数hello
构造函数world
右值拷贝（使用原有资源）hello
右引用赋值（使用原有资源）world
右引用赋值（使用原有资源）hello
析构函数
析构函数