右值引用、完美转发

在写这个文档的时候遇到的低级问题：

class string
{
public:
    string(const char* pStr)
    {
        if (pStr == NULL)
        {
            string();
        }
        else
        {
            m_pStr = new char[strlen(pStr)+1];
            strcpy(m_pStr,pStr);
        }
    }

    string()
    {
        m_pStr = new char[1];
        m_pStr[0] = 0;
    }

    string(const string & right)
    {       

        delete [] m_pStr; //这里就是这个低级问题，构造函数只会调用一次，所以程序在这里会崩溃。
        m_pStr = new char[strlen(right.m_pStr)+1];
        strcpy(m_pStr,right.m_pStr);
    }

...

};

 

 

1.看看没有移动语义的情况效率是多低

(1)两个值交换

void swapString(string str1,string str2)
{
    string tem = str1;
    str1 = str2;
    str2 = tem;
}

这里一个值交换调用了一次拷贝构造函数、两次赋值函数，一共要调用三次 strcpy 操作。如果这里的 swapString 会调用很多次的话，那效率可想有多低。

(2)临时变量给一个命令变量赋值

string tem = string("abc");

这里也会调用一次拷贝构造函数。

 

2.有移动语义的 string的定义

class string
{
public:
    string(const char* pStr)
    {
        if (pStr == NULL)
        {
            string();
        }
        else
        {
            m_pStr = new char[strlen(pStr)+1];
            strcpy(m_pStr,pStr);
        }
    }

    string()
    {
        m_pStr = new char[1];
        m_pStr[0] = 0;
    }

    //普通拷贝构造函数

    string(const string & right)
    {       
        m_pStr = new char[strlen(right.m_pStr)+1];
        strcpy(m_pStr,right.m_pStr);
    }

    //普通赋值函数

    string & operator=(const string &right)
    {
        m_pStr = new char[strlen(right.m_pStr)+1];
        strcpy(m_pStr,right.m_pStr);

        return *this;
    }

    //移动构造函数
    string(string && right)
    {
        m_pStr = right.m_pStr;

        right.m_pStr = new char[1];
        right.m_pStr[0] = 0;
    }

    //移动赋值函数

    string & operator=(string &&right)
    {
        m_pStr = right.m_pStr;

        right.m_pStr = new char[0];
        right.m_pStr[0] = 0;
        return *this;
    }

    ~string(){delete [] m_pStr;}

private:
    char *m_pStr;
};

 

下面是利用移动语义的 swapString函数，这里一次strcpy都没有调用，所以效率提升了。
void swapString(string str1,string str2)
{
    string tem = std::move(str1);
    str1 = std::move(str2);
    str2 = std::move(tem);
}

 

3.什么才具有移动语义

    在c++里面，有名字的变量都是左值。没有名字的变量都是右值。

    只有右值才具有移动语义。所以只有临时变量、无名右值引用才具有移动语义。命名右值引用不具有移动语义。

   ex:

  

void testRRef(string &&right)
{}

int main()
{
    string a;
    string && rTem = string();

    testRRef(rTem);//这里会报错，因为命名右值引用不具有移动语义

    testRRef(string());//正确，临时变量具有移动语义
    testRRef(std::move(rTem));//正确， std::move把rTem转换成了无名右值引用
}

 

(1)左值引用和右值引用绑定的优先级: 右值引用参数绑定的优先级高于 左值引用的优先级。

ex:

void testRRef(string &&right)
{}

void testRRef(string &right)
{}

int main()
{
    string a;
    string && rTem = string();

    testRRef(rTem); //正确，这里会绑定左值引用的 testRRef

    testRRef(string());//正确，这里会绑定右值引用的 testRRef
    testRRef(std::move(rTem));//正确，这里会绑定右值引用的 testRRef

}

 

(2)std::move的作用：

   我们在把命名右值引用转换为无名右值引用的时候，可以使用语句 static_cast<T&&>(t);

   但是为了方便使用，stl提供了一个函数 std::move 封装了 static_cast 这个语句。

   template<class _Ty> inline
   typename tr1::_Remove_reference<_Ty>::_Type&&
   move(_Ty&& _Arg)
  { // forward _Arg as movable
      return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg);
  }

(3)右值引用的初始化和赋值：

右值引用和左值引用一样，在定义的时候必须初始化。

但是 右值引用的初始化只能是 右值引用 或者 是临时变量。

          右值引用的赋值可以是任何类型的变量(左引用、右引用、临时变量、命名变量)

 ex:

string a;

string && tem = a;//不能有命名变量初始化

string && tem = string();//正确

tem = 1;//可以用命名变量初始化

tem = std::move(a);//可以用右值引用初始化

 

4.泛引用

 (1).泛引用的两种形式

     如果一个变量的类型是 auto && ，那么它是一个泛引用；

     在函数模板中，如果一个参数被声明为 T&&, 并且T要由推导才能确定类型，那么它是一个泛引用。

(2).泛引用的推导过程

     泛引用是不稳定的，它的实际类型由所绑定的值来确定。如果绑定的值是左值，那么泛引用就是左引用；如果绑定的值是右值，那么泛引用就是右值引用。

    ex:

    string s;

    string &&rightS = string();

    std::move(s);//由于绑定的值是左值，那么move将是左值引用，但 std::move 仍会返回一个无名右值引用。

    std::move(rightS);//rightS是左值引用，因为 命名右值引用是左值。

    std::move(string());//这里会使一个右值引用。

   

5.完美转发

  (1)看下面的代码，

template <class T>
void test(T && arg){}

template<class T>
void forwardTest( T&& arg)
{
    test(arg);

    T tem = arg;
}

int main()
{

    forwardTest(string());
}

根据泛引用规则，forwardTest将被推导为右值引用，但是这个右值引用变成了命名右值引用，所以 test(arg) 将被推导为左值引用，T tem = arg; 这个语句也只会调用普通的拷贝构造函数。所以可以看出，参数在转发的过程中，变量的右值引用这个特性没有保留下来。

但是我们有解决方案，那就是 std::forward. 

(2)std::forward

为了在参数的传递过程中保证不丢失参数的左右值属性，我们可以使用 std::forward 。

标准库函数 std::forward<T>(t) 有两个参数：模板参数 T 与 函数参数 t。函数功能如下：

    当T为左值引用类型U&时，t 将被转换为无名左值引用（左值，类型为U&）。

    当T为非引用类型U或右值引用类型U&&时，t 将被转换为无名右值引用（右值，类型为U&&）。

 

所以下面的代码就很好的解决了保持参数左右值属性的问题：

template<class T>
void forwardTest( T&& arg)
{
    test(std::forward<T>(arg));

    T tem = std::forward<T>(arg);
}