zoukankan      html  css  js  c++  java
  • C++ 右值引用与move

    C++ 右值引用与move

    右值引用

    C++中所有的值都必然属于左值、右值二者之一。左值是指表达式结束后依然存在的持久化对象,右值是指表达式结束时就不再存在的临时对象
    所有的具名变量或者对象都是左值,而右值不具名。很难得到左值和右值的真正定义,但是有一个可以区分左值和右值的便捷方法:看能不能对表达式取地址,如果能,则为左值,否则为右值。左值一般在内存中,右值一般在内存或CPU寄存器中。
     
    左值引用和右值引用的定义:
    T & ref = lvalue;
    T && ref = rvalue;

    看个例子:

    int main(int argc, char** argv) {
    
        // 左值引用
        int i = 10; 
        int &l = i;
        //int &l = 10;  // Error
        cout << l << endl;
    
        // 右值引用
        int && r = 17; 
        //int && r = i;   // Error
        int *p = &r; 
        cout << *p << endl;
    
        return 0;
    }

    可见,右值引用关联到右值时,右值被存储到特定位置,右值引用指向该特定位置,也就是说,右值虽然无法获取地址,但是右值引用是可以获取地址的,该地址表示临时对象的存储位置。

    既然右值引用可以获取地址,左值引用虽然不能绑定右值,但能绑定右值引用,例如:

    int &&r = 10;  
    int &l = r;
    l = 11;
    cout << r << endl;  // 11
    上面的例子中,左值引用只能绑定左值,右值引用只能绑定右值,如果绑定的不对,编译就会失败。但是,const左值引用却是个奇葩,它可以算是一个“万能”的引用类型,它可以绑定非常量左值、常量左值、右值,而且在绑定右值的时候,常量左值引用还可以像右值引用一样将右值的生命期延长,缺点是,只能读不能改。

    int main(int argc, char** argv) {
        // const左值引用
        const int &r = 10;  
        //r = 11;   // Error
        const int* p = &r; 
        cout << *p << endl;
    
        return 0;
    }

    最后看一个例子:

    class A { 
        public:
            A(int x) :m(x) { cout<< "A(int) called" << endl; }
            A(const A& other) {m=other.m; cout << "A(const A&)" << endl;}
            ~A() { cout<< "~A() called" << endl; }
            int get() {return m;} 
            void set(int x) {m = x;} 
    
        private:
            int m;
    };
    
    A getTemp(int x=10) {
        return A(x);
    }
    
    void AcceptVal(A a) {
    }
    
    void AcceptRef(const A& a) {
    }
    
    int main(int argc, char** argv) {
        AcceptVal(getTemp());   // getTemp返回的是右值(临时变量),应该调用两次拷贝构造函数
        AcceptRef(getTemp());   // const左值引用绑定右值, 应该只调用一次拷贝构造函数
    
        return 0;
    }

    说明:

    getTemp函数返回值会先创建一个临时变量,该临时变量是右值,getTemp返回值拷贝给该变量:

    如果将该变量以值传递调用函数AcceptVal(),实参到形参又会发生一次对象拷贝;

    如果将该变量以引用传递调用函数AcceptRef(),形参是const左值引用,可以绑定右值(实参),不需要任何拷贝。

    PS,以上代码编译需要关闭编译器返回值优化选项,g++ test.cpp -std=c++11 -fno-elide-constructors,否则会发现没有任何拷贝构造函数的调用!

    以上,总结一下,其中T是一个具体类型:

    1. 左值引用, 使用 T&, 只能绑定左值;
    2. 右值引用, 使用 T&&, 只能绑定右值;
    3. 常量左值引用, 使用 const T&, 既可以绑定左值又可以绑定右值;
    4. 已命名的右值引用,编译器会认为是个左值;
    5. 编译器有返回值优化,但不要过于依赖;

    move操作

    move函数在<utility>头文件中。

    先看一个例子:

    #include <iostream>
    #include <cstring>
    #include <vector>
    using namespace std;
    
    class MyString
    {
    public:
        static size_t CCtor; //统计调用拷贝构造函数的次数
    //    static size_t CCtor; //统计调用拷贝构造函数的次数
    public:
        // 构造函数
       MyString(const char* cstr=0){
           if (cstr) {
              m_data = new char[strlen(cstr)+1];
              strcpy(m_data, cstr);
           }
           else {
              m_data = new char[1];
              *m_data = '';
           }
       }
    
       // 拷贝构造函数
       MyString(const MyString& str) {
           CCtor ++;
           m_data = new char[ strlen(str.m_data) + 1 ];
           strcpy(m_data, str.m_data);
       }
       // 拷贝赋值函数 =号重载
       MyString& operator=(const MyString& str){
           if (this == &str) // 避免自我赋值!!
              return *this;
    
           delete[] m_data;
           m_data = new char[ strlen(str.m_data) + 1 ];
           strcpy(m_data, str.m_data);
           return *this;
       }
    
       ~MyString() {
           delete[] m_data;
       }
    
       char* get_c_str() const { return m_data; }
    private:
       char* m_data;
    };
    size_t MyString::CCtor = 0;
    
    int main()
    {
        vector<MyString> vecStr;
        vecStr.reserve(1000); //先分配好1000个空间,不这么做,调用的次数可能远大于1000
        for(int i=0;i<1000;i++){
            vecStr.push_back(MyString("hello"));
        }
        cout << MyString::CCtor << endl;
    }
    发现执行了1000次拷贝构造函数,如果MyString("hello")构造出来的字符串本来就很长,构造一遍就很耗时了,最后却还要拷贝一遍,而MyString("hello")只是临时对象,拷贝完就没什么用了,这就造成了没有意义的资源申请和释放操作,如果能够直接使用临时对象已经申请的资源,既能节省资源,又能节省资源申请和释放的时间。而C++11新增加的移动语义就能够做到这一点。
     
    改进版本:
    #include <iostream>
    #include <cstring>
    #include <vector>
    using namespace std;
    
    class MyString
    {
    public:
        static size_t CCtor; //统计调用拷贝构造函数的次数
        static size_t MCtor; //统计调用移动构造函数的次数
        static size_t CAsgn; //统计调用拷贝赋值函数的次数
        static size_t MAsgn; //统计调用移动赋值函数的次数
    
    public:
        // 构造函数
       MyString(const char* cstr=0){
           if (cstr) {
              m_data = new char[strlen(cstr)+1];
              strcpy(m_data, cstr);
           }
           else {
              m_data = new char[1];
              *m_data = '';
           }
       }
    
       // 拷贝构造函数
       MyString(const MyString& str) {
           CCtor ++;
           m_data = new char[ strlen(str.m_data) + 1 ];
           strcpy(m_data, str.m_data);
       }
       // 移动构造函数
       MyString(MyString&& str) noexcept
           :m_data(str.m_data) {
           MCtor ++;
           str.m_data = nullptr; //不再指向之前的资源了
       }
    
       // 拷贝赋值函数 =号重载
       MyString& operator=(const MyString& str){
           CAsgn ++;
           if (this == &str) // 避免自我赋值!!
              return *this;
    
           delete[] m_data;
           m_data = new char[ strlen(str.m_data) + 1 ];
           strcpy(m_data, str.m_data);
           return *this;
       }
    
       // 移动赋值函数 =号重载
       MyString& operator=(MyString&& str) noexcept{
           MAsgn ++;
           if (this == &str) // 避免自我赋值!!
              return *this;
    
           delete[] m_data;
           m_data = str.m_data;
           str.m_data = nullptr; //不再指向之前的资源了
           return *this;
       }
    
       ~MyString() {
           delete[] m_data;
       }
    
       char* get_c_str() const { return m_data; }
    private:
       char* m_data;
    };
    size_t MyString::CCtor = 0;
    size_t MyString::MCtor = 0;
    size_t MyString::CAsgn = 0;
    size_t MyString::MAsgn = 0;
    int main()
    {
        vector<MyString> vecStr;
        vecStr.reserve(1000); //先分配好1000个空间
        for(int i=0;i<1000;i++){
            vecStr.push_back(MyString("hello"));
        }
        cout << "CCtor = " << MyString::CCtor << endl;
        cout << "MCtor = " << MyString::MCtor << endl;
        cout << "CAsgn = " << MyString::CAsgn << endl;
        cout << "MAsgn = " << MyString::MAsgn << endl;
    }
    
    /* 结果
    CCtor = 0
    MCtor = 1000
    CAsgn = 0
    MAsgn = 0
    */
    可以看到,移动构造函数与拷贝构造函数的区别是,拷贝构造的参数是const MyString& str,是常量左值引用,而移动构造的参数是MyString&& str,是右值引用,而MyString("hello")是个临时对象,是个右值,优先进入移动构造函数而不是拷贝构造函数。而移动构造函数与拷贝构造不同,它并不是重新分配一块新的空间,将要拷贝的对象复制过来,而是"偷"了过来,将自己的指针指向别人的资源,然后将别人的指针修改为nullptr,这一步很重要,如果不将别人的指针修改为空,那么临时对象析构的时候就会释放掉这个资源,"偷"也白偷了。下面这张图可以解释copy和move的区别。

    上面是对一个右值,可以进入移动构造函数,如果对于一个左值,肯定是优先调用拷贝构造函数了,但是有些左值是局部变量,生命周期也很短,能不能也移动而不是拷贝呢?C++11为了解决这个问题,提供了std::move()方法来将左值转换为右值,从而方便应用移动语义。我觉得它其实就是告诉编译器,虽然我是一个左值,但是不要对我用拷贝构造函数,而是用移动构造函数吧。。。

    int main()
    {
        vector<MyString> vecStr;
        vecStr.reserve(1000); //先分配好1000个空间
        for(int i=0;i<1000;i++){
            MyString tmp("hello");
            vecStr.push_back(tmp); //调用的是拷贝构造函数
        }
        cout << "CCtor = " << MyString::CCtor << endl;
        cout << "MCtor = " << MyString::MCtor << endl;
        cout << "CAsgn = " << MyString::CAsgn << endl;
        cout << "MAsgn = " << MyString::MAsgn << endl;
    
        cout << endl;
        MyString::CCtor = 0;
        MyString::MCtor = 0;
        MyString::CAsgn = 0;
        MyString::MAsgn = 0;
        vector<MyString> vecStr2;
        vecStr2.reserve(1000); //先分配好1000个空间
        for(int i=0;i<1000;i++){
            MyString tmp("hello");
            vecStr2.push_back(std::move(tmp)); //调用的是移动构造函数
        }
        cout << "CCtor = " << MyString::CCtor << endl;
        cout << "MCtor = " << MyString::MCtor << endl;
        cout << "CAsgn = " << MyString::CAsgn << endl;
        cout << "MAsgn = " << MyString::MAsgn << endl;
    }
    
    /* 运行结果
    CCtor = 1000
    MCtor = 0
    CAsgn = 0
    MAsgn = 0
    
    CCtor = 0
    MCtor = 1000
    CAsgn = 0
    MAsgn = 0
    */

    再看几个例子

    MyString str1("hello"); //调用构造函数
    MyString str2("world"); //调用构造函数
    MyString str3(str1); //调用拷贝构造函数
    MyString str4(std::move(str1)); // 调用移动构造函数、
    //    cout << str1.get_c_str() << endl; // 此时str1的内部指针已经失效了!不要使用
    //注意:虽然str1中的m_dat已经称为了空,但是str1这个对象还活着,知道出了它的作用域才会析构!而不是move完了立刻析构
    MyString str5;
    str5 = str2; //调用拷贝赋值函数
    MyString str6;
    str6 = std::move(str2); // str2的内容也失效了,不要再使用

    需要注意一下几点:

    1. str6 = std::move(str2),虽然将str2的资源给了str6,但是str2并没有立刻析构,只有在str2离开了自己的作用域的时候才会析构,所以,如果继续使用str2m_data变量,可能会发生意想不到的错误。
    2. 如果我们没有提供移动构造函数,只提供了拷贝构造函数,std::move()会失效但是不会发生错误,因为编译器找不到移动构造函数就去寻找拷贝构造函数,也这是拷贝构造函数的参数是const T&常量左值引用的原因!
    3. c++11中的所有容器都实现了move语义,move只是转移了资源的控制权,本质上是将左值强制转化为右值使用,以用于移动拷贝或赋值,避免对含有资源的对象发生无谓的拷贝move对于拥有如内存、文件句柄等资源的成员的对象有效,如果是一些基本类型,如int和char[10]数组等,如果使用move,仍会发生拷贝(因为没有对应的移动构造函数),所以说move对含有资源的对象说更有意义。



    通用引用(universal references)

    当右值引用和模板结合的时候,就复杂了。T&&并不一定表示右值引用,它可能是个左值引用又可能是个右值引用。例如:
    template<typename T>
    void f( T&& param){
        
    }
    f(10);  //10是右值
    int x = 10; //
    f(x); //x是左值

    如果上面的函数模板表示的是右值引用的话,肯定是不能传递左值的,但是事实却是可以。这里的&&是一个未定义的引用类型,称为universal references,它必须被初始化,它是左值引用还是右值引用却决于它的初始化,如果它被一个左值初始化,它就是一个左值引用;如果被一个右值初始化,它就是一个右值引用。

    注意:只有当发生自动类型推断时(如函数模板的类型自动推导,或auto关键字),&&才是一个universal references

    template<typename T>
    void f( T&& param); //这里T的类型需要推导,所以&&是一个 universal references
    
    template<typename T>
    class Test {
      Test(Test&& rhs); //Test是一个特定的类型,不需要类型推导,所以&&表示右值引用  
    };
    
    void f(Test&& param); //右值引用
    
    //复杂一点
    template<typename T>
    void f(std::vector<T>&& param); //在调用这个函数之前,这个vector<T>中的推断类型
    //已经确定了,所以调用f函数的时候没有类型推断了,所以是 右值引用
    
    template<typename T>
    void f(const T&& param); //右值引用
    // universal references仅仅发生在 T&& 下面,任何一点附加条件都会使之失效

    所以最终还是要看T被推导成什么类型,如果T被推导成了string,那么T&&就是string&&,是个右值引用,如果T被推导为string&,就会发生类似string& &&的情况,对于这种情况,c++11增加了引用折叠的规则,总结如下:

    1. 所有的右值引用叠加到右值引用上仍然使一个右值引用。
    2. 所有的其他引用类型之间的叠加都将变成左值引用。
     
    #include <iostream>
    #include <type_traits>
    #include <string>
    using namespace std;
    
    template<typename T>
    void f(T&& param){
        if (std::is_same<string, T>::value)
            std::cout << "string" << std::endl;
        else if (std::is_same<string&, T>::value)
            std::cout << "string&" << std::endl;
        else if (std::is_same<string&&, T>::value)
            std::cout << "string&&" << std::endl;
        else if (std::is_same<int, T>::value)
            std::cout << "int" << std::endl;
        else if (std::is_same<int&, T>::value)
            std::cout << "int&" << std::endl;
        else if (std::is_same<int&&, T>::value)
            std::cout << "int&&" << std::endl;
        else
            std::cout << "unkown" << std::endl;
    }
    
    int main()
    {
        int x = 1;
        f(1); // 参数是右值 T推导成了int, 所以是int&& param, 右值引用
        f(x); // 参数是左值 T推导成了int&, 所以是int&&& param, 折叠成 int&,左值引用
        int && a = 2;
        f(a); //虽然a是右值引用,但它还是一个左值, T推导成了int&
        string str = "hello";
        f(str); //参数是左值 T推导成了string&
        f(string("hello")); //参数是右值, T推导成了string
        f(std::move(str));//参数是右值, T推导成了string
    }

    所以,归纳一下, 传递左值进去,就是左值引用,传递右值进去,就是右值引用。如它的名字,这种类型确实很"通用",下面要讲的完美转发,就利用了这个特性。

     
     
     


    完美转发

    所谓转发,就是通过一个函数将参数继续转交给另一个函数进行处理,原参数可能是右值,可能是左值,如果还能继续保持参数的原有特征,那么它就是完美的。
    void process(int& i){
        cout << "process(int&):" << i << endl;
    }
    void process(int&& i){
        cout << "process(int&&):" << i << endl;
    }
    
    void myforward(int&& i){
        cout << "myforward(int&&):" << i << endl;
        process(i);
    }
    
    int main()
    {
        int a = 0;
        process(a); //a被视为左值 process(int&):0
        process(1); //1被视为右值 process(int&&):1
        process(move(a)); //强制将a由左值改为右值 process(int&&):0
        myforward(2);  //右值经过forward函数转交给process函数,却称为了一个左值,
        //原因是该右值有了名字  所以是 process(int&):2
        myforward(move(a));  // 同上,在转发的时候右值变成了左值  process(int&):0
        // forward(a) // 错误用法,右值引用不接受左值
    }

    上面的例子就是不完美转发,而c++中提供了一个std::forward()模板函数解决这个问题。将上面的myforward()函数简单改写一下:

    void RunCode(int &&m) {
        cout << "rvalue ref" << endl;
    }
    void RunCode(int &m) {
        cout << "lvalue ref" << endl;
    }
    void RunCode(const int &&m) {
        cout << "const rvalue ref" << endl;
    }
    void RunCode(const int &m) {
        cout << "const lvalue ref" << endl;
    }
    
    // 这里利用了universal references,如果写T&,就不支持传入右值,而写T&&,既能支持左值,又能支持右值
    template<typename T>
    void perfectForward(T && t) {
        RunCode(forward<T> (t));
    }
    
    template<typename T>
    void notPerfectForward(T && t) {
        RunCode(t);
    }
    
    int main()
    {
        int a = 0;
        int b = 0;
        const int c = 0;
        const int d = 0;
    
        notPerfectForward(a); // lvalue ref
        notPerfectForward(move(b)); // lvalue ref
        notPerfectForward(c); // const lvalue ref
        notPerfectForward(move(d)); // const lvalue ref
    
        cout << endl;
        perfectForward(a); // lvalue ref
        perfectForward(move(b)); // rvalue ref
        perfectForward(c); // const lvalue ref
        perfectForward(move(d)); // const rvalue ref
    }

    上面的代码测试结果表明,在universal referencesstd::forward的合作下,能够完美的转发这4种类型。

     
     
     

    emplace*函数

    我们之前使用vector一般都喜欢用push_back(),由上文可知容易发生无谓的拷贝,解决办法是为自己的类增加移动拷贝和赋值函数,但其实还有更简单的办法!就是使用emplace_back()替换push_back(),如下面的例子:
    class A {
    public:
        A(int i){
    //        cout << "A()" << endl;
            str = to_string(i);
        }
        ~A(){}
        A(const A& other): str(other.str){
            cout << "A&" << endl;
        }
    
    public:
        string str;
    };
    
    int main()
    {
        vector<A> vec;
        vec.reserve(10);
        for(int i=0;i<10;i++){
            vec.push_back(A(i)); //调用了10次拷贝构造函数
    //        vec.emplace_back(i);  //一次拷贝构造函数都没有调用过
        }
        for(int i=0;i<10;i++)
            cout << vec[i].str << endl;
    }

    emplace_back()可以直接通过构造函数的参数构造对象,但前提是要有对应的构造函数。

    对于mapset,可以使用emplace()。基本上emplace_back()对应push_bakc()emplce()对应insert()

    移动语义对swap()函数的影响也很大,之前实现swap可能需要三次内存拷贝,而有了移动语义后,就可以实现高性能的交换函数了。
     
    template <typename T>
    void swap(T& a, T& b)
    {
        T tmp(std::move(a));
        a = std::move(b);
        b = std::move(tmp);
    }

    如果T是可移动的,那么整个操作会很高效,如果不可移动,那么就和普通的交换函数是一样的,不会发生什么错误,很安全。

     
     
     
     
     
  • 相关阅读:
    感知机学习算法 python实现
    最小二乘法 python实现
    python数据结构与算法——图的基本实现及迭代器
    python数据结构与算法——二叉树结构与遍历方法
    python数据结构与算法——字典树
    python数据结构与算法——完全树 与 最小/大堆
    win2008服务器asp站点配置要点
    SQL Server分页语句ROW_NUMBER,读取第4页数据,每页10条
    WinForm Control.Invoke&Control.BeginInvoke异步操作控件实例
    Couchbase应用示例(初探)
  • 原文地址:https://www.cnblogs.com/chenny7/p/11984699.html
Copyright © 2011-2022 走看看