【C++ Primer 第13章】6.对象移动

右值引用

左值和右值

（1）两者区别：

　　①左值：能对表达式取地址、或具名对象/变量。一般指表达式结束后依然存在的持久对象。

　　②右值：不能对表达式取地址，或匿名对象。一般指表达式结束就不再存在的临时对象。

总结：一般而言，一个左值表达式表示的是一个对象的身份，而一个右值表达式表示的是对象的值。

（2）右值的分类

　　①将亡值（xvalue，eXpiring value）：指生命期即将结束的值，一般是跟右值引用相关的表达式，这样表达式通常是将要被移动的对象，如返回类型为T&&的函数返回值（如std::move）、经类型转换为右值引用的对象（如static_cast<T&&>(obj)）、xvalue类对象的成员访问表达式也是一个xvalue（如Test().memberdata，注意Test()是个临时对象）

　　②纯右值（prvalue， PureRvalue）：按值返回的临时对象、运算表达式产生的临时变对象、原始字面量和lambda表达式等。

（3）C++11中的表达式

标准库的 move 函数

• 虽然不能将一个右值直接绑定到一个左值上，但可以显式地将一个左值转换为对应的右值引用类型。我们可以通过调用一个名为 move的新标准库函数来获得绑定到左值上的引用。头文件utility。

int &&rr3 = std::move(rr1); //ok

• 我们可以销毁一个移后源对象，也可以赋予它新值，但不能使用一个移后源对象的值。

移动构造函数和移动赋值运算符

• 与拷贝函数不同，移动构函数不分配任何新的内存，它接管给定StrVec中的内存，在接管内存之后， 它将给的对象中的指针置为nullptr，这样就完成了从给定对象的移动操作，此对象将继续存在。

 #include<iostream>
 #include<string>
 #include<memory>
 using namespace std;

 class StrVec {
 public:
     StrVec(): elements(nullptr), first_free(nullptr), cap(nullptr) {}
     StrVec(const StrVec &);
     StrVec& operator=(const StrVec&);
     ~StrVec() { free(); };

     StrVec(StrVec &&s) noexcept;
     StrVec& opearator=(StrVec &&rhs) noexcept;

     void push_back (const string&);
     size_t size() const       { return first_free - elements; }
     size_t capacity() const   { return cap - elements; }
     string *begin() const     { return elements; }
     string *end() const       { return first_free; }

 private:
     static allocator<string> alloc;
     void chk_n_alloc() { if (size() == capacity()) reallocate(); }
     pair<string*, string*> alloc_n_copy(const string*, const string *);
     void free();
     void reallocate();
     string *elements;    //指向数组首元素的指针
     string *first_free;  //指向数组第一个空闲元素的指针
     string *cap;         //指向数组尾后位置的指针
 };

 StrVec::StrVec(const StrVec &s)
 {
     auto newdata = alloc_n_copy(s.begin(), s.end());
     elements = newdata.first;
     first_free = cap = newdata.second;
 }

 StrVec& StrVec::operator=(const StrVec &rhs)
 {
     auto data = alloc_n_copy(rhs.begin(), rhs.end());
     free();
     elements = data.first;
     first_free = cap = newdata.second;
     return *this;
 }

 void StrVec::free()
 {
     if (elements)
     {
         for (auto p = first_free; p != elements; )
             alloc.destroy(--p);
         alloc.deallocate(elements, cap - elements);
     }
 }

 pair<string *, string *> StrVec::alloc_n_copy(const string *b, const string *e)
 {
     auto data = alloc.allocate(e - b);
     return { data, uninitialized_copy(b, e, data) };
 }

 void StrVec::push_back(const string& s)
 {
     chk_n_alloc();
     alloc.construct(first_free++, s);
 }

 void StrVec::reallocate()
 {
     auto newcapacity = size() ?  * size() : ;
     auto newdata = alloc.allocate(newcapacity);
     auto dest = newdata;
     auto elem = elements;  //原对象的elements指针
     for (size_t i = ; i != size(); ++i)
         alloc.construct(dest++, std::move(*elem++));
     free();
     elements = newdata;
     first_free = dest;
     cap = elements + newcapacity;
 }

 StrVec::StrVec(StrVec &&s) noexcept
 : elements(s.elements), first_free(s.first_free), cap(s.cap)
 {
     s.elements = s.first_free = cap = nulllptr;
 }

 StrVec& StrVec::StrVec(StrVec &&s) noexcept
 {
     if (this = &s)
     {
         free();
         elemens = rhs.elements;
         first_free = .frhsirst_free;
         cap = rhs.cap;
         rhs.elements = srhs.first_free = rhs.cap = nullptr;
     }
     return *this;
 }

• 与拷贝操作不同，编译器根本不会为某些类合成移动操作，特别是，如果一个类定义了自己的拷贝构造函数、拷贝赋值运算符或析构函数、编译器根本就不会为它合成移动构造函数。

• 如果一个类有一个可用的拷贝构造函数而没有移动构造函数，则其对象是通过拷贝构造函数来“移动”的，拷贝赋值运算符和移动赋值运算符的情况类似。

拷贝并交换赋值运算符和移动操作

右值引用和成员函数

• 区分移动和拷贝的重载函数通常有一个版本接受一个const T&， 而另一个版本接受一个T&&。

作为一个具体例子，我们将为StrVec类定义另一个版本的push_back：

 class StrVec {
 public:
     void push_back(const std::string&);  //拷贝元素
     void push_back(std:: string&&)       //移动元素
     // 其他成员的定义， 如前
 };

 void StrVec::push_back(const string &s)
 {
     chk_n_alloc();  //确保有空间容纳新的元素
     //在first_free指向的元素中构造s的一个副本
     alloc.construct(first_free++, s);
 }

 void StrVec::push_back(string &&s)
 {
     chk_n_alloc();  // 如果需要的话为StrVec重新分配内存
     alloc.construct(first_free++, std::move(s));
 }

 

右值和左值引用成员函数

 #include <iostream>
 using namespace std;

 class Foo {
 public:
     Foo & operator=(const Foo&) &; //只能向可修改的左值赋值
     Foo anotherMem() const &;      //正确，const 限定符在前

     Foo gg() const &&;   //this 也可以指向一个右值
 };

 Foo& Foo::operator=(const Foo &rhs) &  //引用限定符和const一样必须同时出现在声明和定义中
 {
     //执行将rhs赋予本对象所需的工作
     return *this;
 }

 Foo& retFoo()  //返回一个左值
 {
     return *(new Foo());
 }

 Foo retVal()    //返回一个右值
 {
     return Foo();
 }

 int main(void)
 {
     Foo i, j;
     i = j;
     retFoo() = j;    //正确，retFoo() 返回一个左值
     i = retVal();    //正确，我们可以将一个右值作为赋值运算符右侧运算对象
     return ;
 }

重载和引用函数

 #include <iostream>
 #include <vector>
 #include <algorithm>
 using namespace std;

 class Foo{
 public:
     Foo sorted() &&;        //可用于改变的右值
     Foo sorted() const &;   //可用于任何类型的Foo
     // Foo sorted();        //错误，当有两个以上同名且同参数列表的成员函数时，

     // 要么全(指这些同名且同参数列表的成员函数)都加引用限定符(只要有就行, 不论右值还是左值引用)，要么都不加引用限定符
     Foo sorted(int);//正确，参数列表不同

 private:
     vector<int> data;
 };

 Foo Foo::sorted() &&   // 本对象为右值，因此可以原址排序
 {
     sort(data.begin(), data.end());
     return *this;
 }

 Foo Foo::sorted() const &   // 本对象是const或是一个左值，哪种情况我们都不能原址排序

 {
     Foo ret(*this);                           // 拷贝一个副本
     sort(ret.data.begin(), ret.data.end());   // 副本排序
     return ret;                               // 返回副本
 }

 Foo& retFoo()    //返回一个左值
 {
     return *(new Foo());
 }

 Foo retVal()     //返回一个右值
 {
     return Foo();
 }

 int main(void)
 {
     retVal().sorted();    //retVal() 返回一个右值，调用 Foo::sorted() &&
     retFoo().sorted();    //retFoo() 返回一个左值，调用 Foo::sorted() const &
     return ;
 }

参考资料

【1】右值引用（1）_基本概念