拷贝控制3(对象移动)

在对象拷贝后就立即被销毁的情况下，移动而非拷贝对象会大幅度提升性能。以及像 IO 类或 unique_ptr 这样的类，包含不能被共享的资源，不能拷贝但可以移动。而标准库容器、string 和 shared_ptr 类既支持移动也支持拷贝

 

右值引用：

右值引用是 c++11 为了支持移动操作引入的。右值引用就是只能绑定到右值的引用。我们通过 && 而非 & 来获取右值引用。右值引用只能绑定到一个将要销毁的对象。因此我们可以自由地将一个右值引用的资源 “移动” 到另一个对象中

类似任何引用，右值引用也是某个对象的别名。但右值引用有着与左值引用有着完全相反的引用特性：我们可以将一个右值引用绑定到要求转换的表达式、字面常量或是返回右值的表达式，但不能将一个右值引用绑定到一个左值上：

#include <iostream>
using namespace std;

int main(void){
    int i = 42;
    int &r = i;//正确，r引用i
    // int &&rr = i;//错误，不能将一个右值引用绑定到一个左值上
    // int &r2 = i *42;//错误，i*42 是一个右值表达式
    const int &r2 = i * 42;//正确，常量左值引用可以绑定右值
    int &&rr2 = i * 42;//正确，右值引用绑定到右值上

    // 右值引用类型变量本身是左值的，但其算术/关系表达式是右值的
    // int &&cnt1 = rr2;//错误,rr2变量是左值(虽然它本身是一个右值引用)
    int &&cnt2 = rr2 * 1;//正确，rr2*1 是一个右值表达式

    int &&cnt3 = 42;//字面常量是右值

    //转换表达式会生成一个临时变量，即转换表达式的返回值是右值
    int &&cnt4 = float(i);

    //右值引用可以赋值右值引用
    cnt4 = cnt3;
    cout << cnt4 << endl;//42

    return 0;
}

注意：返回左值引用的函数，连同赋值、下标、解引用和前置递增 / 递减运算符都是返回左值的。而返回非引用类型的函数，连同算术、关系、位以及后置递增  / 递减运算符都生成右值

变量都是左值，右值引用类型的变量同样是左值，因此我们不能将一个右值引用绑定上一个右值引用类型的变量上

类似于左值引用，右值引用引用之间也可以赋值

 

左值持久，右值短暂：

左值有持久的状态，而右值要么是字面常量，要么是在表达式求值过程中创建的临时对象

由于右值引用只能绑定到临时对象，我们得知：

所引用的对象将要被销毁

该对象没有其它用户

这意味着：使用右值引用的代码可以自由的接管所引用的对象的资源

 

标准库 move 函数：

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

int cnt = 1;
int &&gg = std::move(cnt);

move 调用告诉编译器，我们有一个左值但我们希望像处理右值一样处理它。

调用 move 也意味着承若：除了对 cnt 赋值或销毁外，我们将不再使用它。在调用 move 之后，我们不能对移后源对象的值做任何假设

 

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

移动构造函数的第一个参数必须是右值引用，其余参数都必须有默认实参

除了完成资源移动，移动构造函数还必须确保移后源对象处于这样一个状态——销毁它是无害的。特别是，一旦资源完成移动，源对象必须不再指向被移动的资源——这些源对象的所有权已经归属新创建的对象：

StrVec::StrVec(StrVec &&s) noexcept :
    elements(s.elements), first_free(s.first_free), cap(s.cap) {
        //令s进入这样的状态——对其运行析构函数是安全的
        s.elements = s.first_free = s.cap = nullptr; 
}

注意：noexcept 通知标准库我们的构造函数不抛出任何异常

与拷贝构造函数不同，移动构造函数不分配任何新内存，它接管给定的 StrVec 中的内存。在接管内存之后，将给定对象中的指针都置为 nullptr，保证完成移动构造函数后源对象被销毁不会释放掉我们刚刚移动的内存

 

移动操作、标准库容器和异常：

移动构造函数通常不分配任何资源，因此移动构造操作通常不会抛出任何异常。我们应该将此事通知标准库，否则标准库会认为移动我们的类对象可能会抛出异常并为了处理这种可能性而做一些额外的工作

一种通知标准库的方法是在我们的移动构造函数中指明 noexcept。在一个构造函数中，noexcept 出现在参数列表和初始化列表的冒号之间：

class StrVec{
public:
    StrVec(StrVec&&) noexcept;//移动构造函数
    ...
    
};

StrVec::StrVec(StrVec &&s) noexcept : /*成员初始化器*/{
    /*构造函数体*/
}

 注意：不抛出异常的移动构造函数和移动赋值运算符必须标记为 noexcept

 

移动赋值运算符：

StrVec& StrVec::operator=(StrVec &&rhs) noexcept {
    if(this != &rhs){//检测自赋值的情况
        free();//释放已有元素
        elements = rhs.elements;
        first_free = rhs.first_free;
        cap = rhs.cap;
        rhs.elements = rhs.first_free = rhs.cap = nullptr;//将rhs置于可析构状态
    }
    return *this;
}

注意：特殊处理自赋值的情况

不抛出异常的移动构造函数和移动赋值运算符必须标记为 noexcept

在移动操作后，移后源对象必须保持有效的、可析构的状态，但是用户不能对其值进行任何假设

 

合成的移动操作：

 如果我们不声明自己的拷贝构造函数或拷贝赋值运算符，编译器总会为我们合成这些操作。与拷贝操作不同，如果一个类定义了自己的拷贝构造函数、拷贝赋值运算符或者析构函数，编译器就不会为它合成移动构造函数和移动赋值运算符了。如果一个类没有移动操作，通过正常的函数匹配，类会使用对应的拷贝操作来代替移动操作：

#include <iostream>
using namespace std;

//编译器会为X和hasX合成移动操作

struct X {
    int i;//内置类型可以移动
    std::string s;//string定义了自己的移动操作
};

struct hasx {
    X mem;//x有合成的移动操作
};

int main(void){
    X x, x2 = std::move(x);//使用合成的移动构造函数
    hasx hx, hx2 = std::move(hx);//使用合成的移动构造函数

    return 0;
}

注意：只有当一个类没有定义任何自己版本的拷贝控制成员，且类的每个非 static 数据成员都可以移动时，编译器才会为它合成移动构造函数或移动赋值运算符。

 

移动操作的删除函数：

与拷贝操作不同，移动操作永远不会隐式定义为删除函数。但是，如果我们显示地要求编译器生成 = default 的移动操作，且编译器不能移动所有非 static 成员，则编译器会将移动操作定义为删除函数。一般情况下，合成的移动操作定义为删除的函数要遵循与定义为删除的合成拷贝操作类似的原则：

与拷贝构造函数不同，移动构造函数被定义为删除的函数的条件是：有类成员定义了自己的拷贝构造函数且未定义移动构造函数，或者是有类成员未定义自己的拷贝构造函数且编译器不能为其合成移动构造函数。移动赋值的情况类似

如果有类所有的移动构造函数或移动赋值运算符被定义为删除的或是不可访问的，则类的移动构造函数或移动赋值运算符被定义为删除的

类似拷贝构造函数，如果类的析构函数被定义为删除的或不可访问的，则类的移动构造函数被定义为删除的

类似拷贝赋值运算符，如果有类成员是 const 的或是引用的，则类的移动赋值运算符被定义为删除的

#include <iostream>
using namespace std;

class Y {
private:
    int i;
    std::string *s;

public:
    Y(int a = 0, string ss = "") : i(a), s(new std::string(ss)) {
        cout << "gou zao" << endl;
    }
    Y(const Y &it) : i(it.i), s(new string(*it.s)) {
        cout << "kao bei gou zao" << endl;
    }
    Y(Y&&) = delete;
};

//编译器将会给hasy合成一个删除的移动构造函数
class hasy {
public:
    hasy() = default;
    hasy(hasy&&) = default;

private: 
    Y mem;
};

int main(void){
    hasy hy, hy2 = std::move(hy);//错误，hasy的移动构造函数是删除的

    return 0;
}

注意：定义了一个移动构造函数或移动赋值运算符的类必须也定义自己的拷贝操作，否则，这些成员默认地被定义为删除的

 

移动右值，拷贝左值：

如果一个类既有移动构造函数，也有拷贝构造函数，编译器使用普通的函数匹配规则来确定使用哪个构造函数：

#include <iostream>
#include "StrVec.h"
using namespace std;

StrVec getVec(void) {
    StrVec gg;
    return gg;
}

int main(void) {
    StrVec v1, v2;
    v1 = v2;//v2是左值，使用拷贝赋值

    v2 = getVec();//getVec()返回一个右值，使用移动赋值

    return 0;
}

 

如果没有移动构造函数，右值也被拷贝：

#include <iostream>
using namespace std;

class Foo{
public:
    Foo() = default;
    Foo(const Foo &it) : x(it.x) {
        cout << "kao bei gou zao han shu" << endl;
    }
    
private:
    int x;

};//Foo定义了拷贝构造函数且未定义移动构造函数,因此其没有移动构造函数

int main(){
    Foo x;
    Foo y(x);//拷贝构造函数，x是一个左值
    Foo z(std::move(x));//拷贝构造函数，因为未定义移动构造函数

    return 0;
}

注意：在对 z 进行初始化时，我们调用了 move(x)，它返回一个绑定到 x 的 Foo&&。但 Foo 类没有移动构造函数，而且 Foo&& 转换为一个 const Foo& 是可行的，因此会匹配到 Foo 的拷贝构造函数

 

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

HasPtr.h：

#pragma once

#include <iostream>

class HasPtr{
friend void swap(HasPtr&, HasPtr&);

public:
    HasPtr(const std::string &s = std::string(), int a = 0) : ps(new std::string(s)), i(a) {}
    HasPtr(const HasPtr&);
    HasPtr(HasPtr&&) noexcept;//移动构造函数
    HasPtr& operator=(HasPtr);//赋值运算符既是移动赋值运算符，也是拷贝赋值运算符
    ~HasPtr(){
        delete ps;
    }

    std::ostream& print(std::ostream &os);

private:
    std::string *ps;
    int i;
};

HasPtr.cpp：

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

//拷贝构造函数
HasPtr::HasPtr(const HasPtr &p) : ps(new std::string(*p.ps)), i(p.i) {
    std::cout << "kao bei gou zao han shu" << std::endl;
}

//移动构造函数
HasPtr::HasPtr(HasPtr &&p) noexcept : ps(p.ps), i(p.i) {//不会抛出异常，将其标记为noexcept
    p.ps = nullptr;//确保移动后源对象是安全的
    std::cout << "yi dong gou zao han shu" << std::endl;
}

//赋值运算符既是移动赋值运算符，也是拷贝赋值运算符
HasPtr& HasPtr::operator=(HasPtr rhs){//注意这里不能是引用
    swap(*this, rhs);//交换后rhs指向本对象曾经使用的内存
    std::cout << "fu zhi yun suan fu" << std::endl;
    return *this;//作用域结束，rhs被销毁，从而delete了rhs中的指针
}

inline
void swap(HasPtr &lhs, HasPtr &rhs){
    std::swap(lhs.ps, rhs.ps);
    std::swap(lhs.i, rhs.i);
}

std::ostream& HasPtr::print(std::ostream &os){
        os << i << " " << *ps << " " << ps;
        return os;
    }

ac31.cpp：

#include <iostream>
#include "HasPtr.h"
using namespace std;

int main(void){
    HasPtr hp2, hp;
    hp = hp2;//hp2是一个左值，通过拷贝构造函数构造赋值运算符的形参
    hp = std::move(hp2);//move返回右值，通过移动构造函数构造赋值运算符的形参

    return 0;
}

注意：此类的运算符有一个非引用参数，这意味着此参数要进行拷贝初始化。依赖于实参的类型，拷贝初始化要么使用拷贝构造函数，要么使用移动构造函数——左值被拷贝，右值被移动。因此，单一的赋值运算符就实现了拷贝赋值运算符和移动赋值运算符两种功能

 

移动迭代器：

c++11 标准库中定义了一种移动迭代器适配器，移动迭代器解引用生成一个右值引用。我们通过调用 make_move_iterator 函数将一个普通迭代器转换成一个移动迭代器。此函数接受一个迭代器参数，返回一个移动迭代器。原迭代器的所有操作在移动迭代器中都照常工作：

void StrVec::reallocate(){
    auto newcapacity = size() ? 2 * size() : 1;
    auto newdata = alloc.allocate(newcapacity);//分配新内存

    //将旧的数据移动到新内存中
    // auto dest = newdata;//指向新数组中下一个空闲位置
    // auto elem = elements;//z指向旧数组中下一个位置
    // for(size_t i = 0; i !=size(); ++i){
    //     alloc.construct(dest++, std::move(*elem++));//移动而非构造一个新的string
    // }
    auto last = uninitialized_copy(make_move_iterator(begin()), make_move_iterator(end()), newdata);
    free();//释放旧内存
    elements = newdata;
    // first_free = dest;
    first_free = last;
    cap = elements + newcapacity;
}

注意：标准库不保证哪些算法适用移动迭代器，哪些不适用。由于移动一个对象可能销毁原对象，因此只有确信算法在为一个元素赋值或将其传递给一个用户定义的函数后不再访问它时，才能使用移动迭代器传递给算法

 

右值和左值引用成员函数：

通常，我们在一个对象上调用成员函数，而不管对象是一个左值还是一个右值：

#include <iostream>
using namespace std;

int main(void){
    string s1 = "a value", s2 = "another";
    auto n = (s1 + s2).find('a');//在一个string右值上调用find

    s1 + s2 = "woe!";//给一个右值赋值,虽然这是毫无意义的,但是正确的

    return 0;
}

 

引用限定符：

但是我们可能希望在自己的类中阻止给右值赋值。即强制左侧运算对象(this 指向的对象) 是一个左值：

指出 this 的左值 / 右值属性的方式与定义 const 成员函数相同——在参数列表后放置一个引用限定符：

#include <iostream>
using namespace std;

class Foo{
public:
    Foo& operator=(const Foo&) &;//只能向可修改的左值赋值,
    // &和const一样用来修饰this指向的对象的
    // Foo();
    // ~Foo();

    // Foo someMem() & const;//错误，const 限定符必须在前
    Foo anotherMem() const &;//正确，const 限定符在前

    Foo gg() const &&;//this 也可以指向一个右值
    // Foo yy() && const;//指向右值时const同样不能在后面
};

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是左值
    
    i = j;//正确，i是左值

    retFoo() = j;//正确，retFoo() 返回一个左值
    // retVal() = j;//错误，retVal() 返回一个右值
    i = retVal();//正确，我们可以将一个右值作为赋值运算符右侧运算对象

    return 0;
}

注意：引用限定符可以是 & 或 &&，分别指出 this 可以指向一个左值或右值。

类似 const 限定符，引用限定符只能用于非 static 成员函数且必须同时出现在函数的声明和定义中

一个函数可以同时用 const 和引用限定。但引用限定符必须跟随在 const 限定符之后

 

重载和引用函数：

#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;
}

//本对象是const或是一个左值，哪种情况我们都不能原址排序
Foo Foo::sorted() 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 0;
}

注意：同名且具有相同参数列表的成员函数要么全部加引用限定符(只要有就行，不论是左值引用还是右值引用)，要么全都不加引用限定符