c++ 11 移动语义、std::move 左值、右值、将亡值、纯右值、右值引用

为什么要用移动语义

先看看下面的代码

// rvalue_reference.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

class HugeMem
{
public:
    HugeMem(int size) : sz(size)
    {
        pIntData = new int[sz];
    }
    HugeMem(const HugeMem & h) : sz(h.sz)
    {
        pIntData = new int[sz];
        for (int i = 0; i < sz; i++)
            pIntData[i] = h.pIntData[i];
    }
    ~HugeMem()
    {
        delete pIntData [];
    }

    int *pIntData;
    int sz;
};

HugeMem GetTemp()
{
    return HugeMem(1024);
}

int _tmain(int argc, _TCHAR* argv[])
{
    HugeMem a = GetTemp();
     return 0;
}

以上代码拷贝构造函数会被调用两次，一次是从GetTemp函数中有HugeMem()生成的一个临时值用作返回值，另外一次则由临时值构造出main中的变量a。析构函数调用了三次。这个过程如果指针指向非常大的内存时拷贝构造 的代价相当昂贵。而令人堪忧的是：临时变量的生产和销毁以及拷贝构造的发生对于程序员来说基本上是透明的，不会影响程序的正确性，因而即使该问题导致性能不佳，也不易被程序员察觉。

而关键的问题是，临时对象在构造和释放时，一去一来似乎并没有太大意义，那么我们是否可以在临时对象构造a时不分配内存，即不使用所谓的拷贝构造函数呢？

那有人又要问了，为什么不用指针会给GetTemp的参数?首先需要指针或引用的方法而不返回值的话，通常需要很多条语句来完成上面的工作。

例如以下语句：

Caculate(GetTeam(),SomeOther(mabe(),UseFul(Value,2)));

但是如果通过传引用和指针而不返回值的话，那需要多条语句来完成上面的工作：
string * a,vector b;//事先声明一些变量用于传递返回值
...
UseFul(Value,2,a)
SomeOther(maybe(),a,b);
Caculate(GetTemp(),b)

 

此时移动语义应运而生。

要想了解移动语义，则需要从左值和右值说起。

左值和右值

判断左值和右值的方法有两种

1.在等号左边的值就称为左值而在等号右边的称为右值

2.另外在c++中还有一种判别方法就是可以取地址，有名的就是左值，不能取地址，没有名的就是右值

例如：

a = b + c

a在等号左边被值为左值

b+c在等号右边被称为右值

a有名，可以取地址称为左值

b+c没名，不可以取地址称为右值

 

纯右值、将亡值

在c++ 11中右值被分为纯右值和将亡值

其中纯右值就是c++98中的标准右值用于标记临时变量或不根对象有关的值。

将亡值是在c++ 11中跟右值引用相关的表达式，这种表达式通常是被移动的对象（移为他用），比如返回右值引用T&&的函数返回值 ,std::move的返回值，或者转换为T&&的类型转换函数的返回值，而剩余的可以标识函数，对象的值都属于左值。

在c++ 11中，所有的值必须为左值、纯右值、将亡值的三种的任一一种。

右值引用

c++ 11中，右值引用就是对一个右值进行引用 的类型，事实上，通常右值不巨有名称，我们只能通过引用来找到他的存在 一般情况下，我们只能从右值表达式获得他的引用

int && c = RetValue();

c++ 98的引用（左值引用）

c++ 98中的引用一般都称为左值引用

int d = 100;
int & dd = d;//这种是c++98里面的左值引用

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

右值引用相当于给右值“续期”

在上面右值引用的例子中,RetValue()在函数返回右值表达式结束后，他的生命也就终结了，而右值引用的声明，又给他“重获新生”，他的生命周期将与他的右值引用c的生命周期一样，只要c还活前些，该右值临时变量都会一直存活下去

所以相比以下声明

CObj c = RetValue()

CObj && c = RetValue()

不使用右值引用就会多一次构造和析构

声明一个右值引用的类型前提是RetValue()返回的是一个右值，通常情况下右值引用是不能够绑定左值的。比如下面的代码是无法通过编译的

int d = 100;
int & dd = d;//这种是c++98里面的左值引用 
int && dd2 = d;//无法通过编译 ，编译器提示无法将右值引用绑定到左值

相应的，是否可以将一个左值引用绑定一个右值呢，例如：

int & d = 100;//不可以，编译错误

以上代码说明相应的左值引用无法绑定一个右值

但是c98有一种常左值引用就是const T&，这在c98里是“万能”引用类型，他可以接受，非常量左值，常量左值，右值对其初始化例如：

int d = 100;

const int e  = 100;

const int & c = d;//接受一个非常量左值
const int & v = e;//接受一个常量左值
const int & z = 3 + 4;//接受一个右值

c98中常量左值引用经常被用于降低临时对象的开销，例如：

int Add(const T & s1,const T & s2);

在c++ 11中，也可以用右值引用来做函数的参数，这样同样可以降低临时变量开销例如：

void Test(CTestObj && a) //在函数内部还可以修改引用a 的值

就本例而言我们可以这样写这个函数

void Test(CTestObj && a)
{
     CTestObj b = std::move(a)   ;
}

std::move的作用时，强制使一个左值成为右值，使用移动语义的前提是CTestObj还需要添加一个右值引用为参数的移动构造函数。

这样一来CTestObj类的临时对象（即ReturnValue的返回的临时值）包含一些大块指针，就可以从临时对象中“窃”为已用。事实上右值引用的存在从来就是和移动语义有关。

假如我们没有为CTestObj声明一个移动构造函数，而只声明一个常量左值为参数的构造函数会发生什么？如同我们前面所说的常量左值引用是一个万能的引用，无论常量左值，非常量左值，右值都可以。那么如果我们不声明移动构造函数，下列语句：

CTestObj b = std::move(a)

将调用常量左值引用为参数的拷贝构造函数。这是一种非常安全的设计----移动不成至少还可以执行拷贝。因此程序页会为声明了移动构造函数的类声明一个常量左值引用为参数的拷贝构造函数，以保证移动不成时可以拷贝构造 。

为了语义完整c++ 11中还存在一个常量右值引用例如：

const T && a = ReturnRValue()

不过常量右值引用一般没有用武之地。

std::move强制转化为右值

std::move并不能移动任何东西，他唯一的功能是将左值转化为右值，继而我们可以用右值引用引用这个值，以用于移动语义。

// rvalue_reference.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
class Moveable
{
public:
    Moveable() :i(new int(3)) {}
    ~Moveable() { delete i;}
    Moveable(const Moveable & s) : i(new int(*s.i)) {}
    Moveable(Moveable && s) : i(s.i)
    {
        s.i = nullptr;
    }

    int * i;
};

int _tmain(int argc, _TCHAR* argv[])
{
    Moveable a;
    Moveable c = a; //这里会调用拷贝构造函数

    Moveable d;
    Moveable e(std::move(d));//这里会调用移动构造函数

    std::cout << *d.i << std::endl;//这里会出现违规访问此时i指针为nullptr
    
     return 0;
}

以上是典型的误用std::move的例子，事实上要使用该必须是程序员清楚需要转换的时候。比如上面代码中程序员应该知道被转化为右值的a不可以再使用。我们需要转化为右值引用还是应该是一个确实生命周期即将结束的对象。

下面是一个正确使用std::move的例子

// rvalue_reference.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

class HugeMem
{
public:
    HugeMem(int size) : sz(size > 0 ? size : 1)
    {
        c = new int[sz];
    }
    ~HugeMem()
    {
        delete [] c;
    }
    HugeMem(HugeMem && hm) : sz(hm.sz), c(hm.c)
    {
        hm.c = nullptr;
    }

    int *c;
    int sz;
};


class Moveable
{
public:
    Moveable() :i(new int(3)),h(1024) {}
    ~Moveable() { delete i;}
    Moveable(Moveable && s) : i(s.i), h(std::move(s.h))
    {
        s.i = nullptr;
    }
    HugeMem h;
    int * i;
};

Moveable GetTemp()
{
    Moveable temp = Moveable();
    std::cout << std::hex << "huge mem GetTemp:" << " @" << temp.h.c << std::endl;
    return temp;

}
int _tmain(int argc, _TCHAR* argv[])
{
    Moveable a(GetTemp());
    std::cout << std::hex << "huge mem main:"  << " @" << a.h.c << std::endl;
    
     return 0;
}

运行结果：

 

 

由结果可以看出移动语义解决了拷贝语文带来的拷贝开销，在拷贝内存较大时，性能犹为明显

如果没有std::move会怎样？

因为移动构造函数的参数是 (T && b)，右值引用参数可以接收的值为非常量右值，其它值都不可以转化为右值引用参数，所以必须要用到std::move