深入理解（实例） -- c++ 右值引用 左值引用

c++ 右值引用 左值引用

下面代码 看出右值引用 跟左值引用的相似之处，都具有别名的左右，可以与它引用的变量共同修改地址内的内容
左值/右值引用可以延长临时变量的寿命，直到该右值引用的寿命结束才析构
右值引用可以直接引用临时变量（如常量 1 ，3.1等），且可以对它进行修改（不指定const）
左值引用一般不会用于引用临时变量，虽然通过一些手段可以编译成功，但不安全也没有意义

struct RefTest{    RefTest()    {        str = "constructor";    }    ~RefTest()    {        str = "destructor";        std::cout<<str.c_str()<<" ~RefTest"<<std::endl;    }    std::string&& getrvalue_ref() &&    {        return std::move(str);    }    std::string& getlvalue_ref()    {        return (str);    }    std::string str;};void test1(){    RefTest a;    RefTest&& b = std::move(a);    std::cout<<a.str.c_str()<<"\t"<<b.str.c_str()<<std::endl;    a.str = "change";    std::cout<<a.str.c_str()<<"\t"<<b.str.c_str()<<std::endl;//constructor   constructor//  change  change//    int& c = 3; //不能编译通过，右边是右值    int&& c = 3;    c++;    std::cout<<c<<"\t"<<std::endl;//4    RefTest(); //立即析构//  destructor ~RefTest    RefTest&& d = RefTest(); //函数结束后析构    d.str = "change";    std::cout<<d.str.c_str()<<std::endl;//  change    std::string&& e = RefTest().getrvalue_ref();    std::cout<<e.c_str()<<"\t"<<std::endl;    e = "change";    std::cout<<e.c_str()<<"\t"<<std::endl;//  destructor ~RefTest//  destructor//  change    std::string& f = RefTest().getlvalue_ref();    std::cout<<f.c_str()<<"\t"<<std::endl;    f = "change";    std::cout<<f.c_str()<<"\t"<<std::endl;//  destructor ~RefTest//  destructor//  change//  destructor ~RefTest//  destructor ~RefTest}

对于函数的返回值如果是临时变量（函数内建的变量，既不是参数变量也不是类成员变量），不能返回引用！
对c++ 在编译的时候会对返回值进行优化，如果返回的是临时变量（注意不是引用！），则会直接使用该临时变量的地址，不会进行内容的迁移和内参的释放，因此效率比较高。这也说明返回值处一般不需要使用move来强制转换右值，多此一举。

int getrvalue(){    return 2;}int& getlvalue_ref(){    int a = 3;    return a;}struct Rvaluetest{    Rvaluetest(int i):str(new char[15])    {        value = i;        str[0] = 'c';        str[1] = 0;        cstr = "test";    }    ~Rvaluetest()    {        value = 0;        std::cout<<" ~Rvaluetest "<<cstr.c_str()<<std::endl;        delete str;    }    int value = 2;    char * const str;    std::string cstr;};Rvaluetest&& getrvalue_ref(){    Rvaluetest a(5);    return std::move(a);}Rvaluetest getrvalue_test(){    Rvaluetest a(5);    return (a);}void RefTest(){//  int& c =  getrvalue();  //error invalid initialization of non-const reference of type ‘int&’ from an rvalue of type ‘int’    const int& c =  getrvalue();    std::cout<<c<<"\t"<<std::endl;//  2    int&& d =  getrvalue();    d++;    std::cout<<d<<"\t"<<std::endl;//  3    int& e = getlvalue_ref();  //编译能通过 但 再次调用该变量会出现 Segmentation fault//  std::cout<<e<<"\t"<<std::endl;  //Segmentation fault    Rvaluetest&& f = getrvalue_ref();    std::cout<<++f.value<<"\t"<<f.str<<" "<<f.cstr.c_str()<<std::endl;    //乱码，说明运行了析构函数，因此虽然能够编译通，并能够运行，但是不安全    //右值引用终究还是引用，他并没有对内存的释放权，如果它引用的内存寿命短暂，可能会出错// ~Rvaluetest test//  1    �$���    Rvaluetest g = getrvalue_test();  //因为c++ 编译器的优化，该函数内建的临时变量并没有运行析构函数，而是整体通过返回值返回转移到g，寿命延长                                      //函数的返回值是右值，这也说明，c++中右值的赋值是直接地址赋值，并没有内容的迁移和内参释放，高效    std::cout<<++g.value<<"\t"<<g.str<<" "<<g.cstr.c_str()<<std::endl;//  6   c test// ~Rvaluetest test}