C++中的左值、右值、左值引用、右值引用和移动语义

C++中的左值、右值、左值引用、右值引用和移动语义

一、c++ 中的左值和右值

误区：左值位于等号左边，右值位于等号右边。

C++11 中的定义：左值表达式表示的是一个对象的身份（在内存中的位置），而右值表达式表示的是对象的值（内容）。

左值和右值都是针对表达式而言的，左值是持久的，右值是短暂的：左值在表达式结束后仍然存在，右值在表达式结束后会被销毁。

区分左值和右值的方法：看能不能进行取地址操作，若能，则为左值，否则为右值。

注意：在需要右值的地方可以用左值来代替，但是不能把右值当成左值（也就是位置）使用。

总结：

C++对于左值和右值没有标准定义，有一个被广泛认同的说法：

• 可以取地址的，有名字的，非临时的就是左值；
• 不能取地址的，没有名字的，临时的就是右值；

二、左值引用和右值引用

基本认识：引用的本质是给变量取个别名

左值引用和右值引用都是属于引用类型。无论是声明一个左值引用还是右值引用，都必须立即进行初始化。而其原因可以理解为是引用类型本身自己并不拥有所绑定对象的内存，只是该对象的一个别名。

左值引用是具名变量值的别名，而右值引用则是不具名（匿名）变量的别名。

左值引用符：&

右值引用符：&&

左值引用和右值引用使用规则

左值引用不能绑定到右值对象上，右值引用也不能绑定到左值对象上。

由于右值引用只能绑定到右值对象上，而右值对象又是短暂的、即将销毁的。也就是说右值引用有一个重要性质：只能绑定到即将销毁的对象上。

左值、右值引用的几个例子：

int i = 42;//如前所述，i是一个左值对象
int &r = i;//正确，左值引用绑定到左值对象i
int &&rr = i;//错误，右值引用绑定左值对象
int &r2 = i * 42;//错误，如前所述i*42是临时变量，是右值，而&r2是左值引用
int &&rr2 = i * 42;//正确，右值引用绑定右值对象

注意：以上绑定规则有一个例外，如果左值引用是 const 类型的，则其可以绑定到右值对象上。

const int &r3 = i * 42;//正确，我们可以将一个const的引用绑定到一个右值对象上

对于一个左值，若想使用其右值引用，我们可以用 move 函数：

int &&rr3 = std::move(rr1);//正确，显式使用rr1的右值引用

右值引用的存在并不是为了取代左值引用，而是充分利用右值(特别是临时对象)的构造来减少对象构造和析构操作以达到提高效率的目的。

三、移动语义

为什么需要移动语义

右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。

转移语义是和拷贝语义相对的，可以类比文件的剪切与拷贝，当我们将文件从一个目录拷贝到另一个目录时，速度比剪切慢很多。

通过转移语义，临时对象中的资源能够转移其它的对象里。

移动语义定义

在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。要实现转移语义，需要定义转移构造函数，还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。

如果转移构造函数和转移拷贝操作符没有定义，那么就遵循现有的机制，拷贝构造函数和赋值操作符会被调用。

普通的函数和操作符也可以利用右值引用操作符实现转移语义。

转移构造函数

class MyString
{
public:
    MyString(const char *tmp = "abc")
    {//普通构造函数
        len = strlen(tmp);  //长度
        str = new char[len+1]; //堆区申请空间
        strcpy(str, tmp); //拷贝内容

        cout << "普通构造函数 str = " << str << endl;
    }

    MyString(const MyString &tmp)
    {//拷贝构造函数
        len = tmp.len;
        str = new char[len + 1];
        strcpy(str, tmp.str);

        cout << "拷贝构造函数 tmp.str = " << tmp.str << endl;
    }

    //移动构造函数
    //参数是非const的右值引用
    MyString(MyString && t)
    {
        str = t.str; //拷贝地址，没有重新申请内存
        len = t.len;

        //原来指针置空
        t.str = NULL;
        cout << "移动构造函数" << endl;
    }

    MyString &operator= (const MyString &tmp)
    {//赋值运算符重载函数
        if(&tmp == this)
        {
            return *this;
        }

        //先释放原来的内存
        len = 0;
        delete []str;

        //重新申请内容
        len = tmp.len;
        str = new char[len + 1];
        strcpy(str, tmp.str);

         cout << "赋值运算符重载函数 tmp.str = " << tmp.str << endl;

        return *this;

    }

    ~MyString()
    {//析构函数
        cout << "析构函数: ";
        if(str != NULL)
        {
            cout << "已操作delete, str =  " << str;
            delete []str;
            str = NULL;
            len = 0;

        }
        cout << endl;
    }

private:
    char *str = NULL;
    int len = 0;
};

MyString func() //返回普通对象，不是引用
{
    MyString obj("mike");

    return obj;
}

int main()
{
    MyString &&tmp = func(); //右值引用接收

    return 0;
}

和拷贝构造函数类似，有几点需要注意：

• 参数（右值）的符号必须是右值引用符号，即“&&”。
• 参数（右值）不可以是常量，因为我们需要修改右值。
• 参数（右值）的资源链接和标记必须修改，否则，右值的析构函数就会释放资源，转移到新对象的资源也就无效了。

有了右值引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计转移构造函数和转移赋值函数，以提高应用程序的效率。