C/C++编程：移动和拷贝

缺乏、安全感 2022-03-31 14:06 391阅读 0赞

当我们需要从a到b传输一个值的时候，通常有两种逻辑上不同的方法：

*  **拷贝**(copy)是x=y的常规定义：即结果x和y的值都等于赋值前y的值
 *  **移动**(move)是x变为y的旧值，y变为某种移除状态。

一般来说，移动操作不能抛出异常，而拷贝操作可以，而且，标准库算法要求能够向一个移除状态的对象进行赋值。换句话说，设计移动操作时不要让它抛出异常，并令源对象处于可析构和赋值的状态。

为了避免重复工作，拷贝和移动操作都有默认定义。

# 拷贝 #

## 拷贝与异常 ##

类X的拷贝操作有两种：

*  拷贝构造函数：比如`X(const X&)`
 *  拷贝赋值运算符：比如`X& operator=(const X&)`

template<typename T>
    class Matrix{
        
    	array<int, 2> dim;
    	T* elem;
    public:
    	Matrix(int d1, int d2) : dim{
        d1, d2}, elem{
        new T[D1*D2]}{
        }
    	int size() const {
        return dim[0]*dim[1]};
    
    	Matrix(const Matrix&);  //拷贝构造函数
    	Matrix& operator=(const Matrix&);
    };

上面如果是默认拷贝可能带来灾难性的后果：Matix的元素不会被复制，副本中只是包含一个指向与源对象相同元素的指针，因此其析构函数会shift键元素两次。 因此，必须手动定义一个拷贝操作

template<typename T>
    Matrix::Matrix(const Matrix&m): dim{
        m.dim}, elem{
        new T[m.size()]}{
        
    	uninitialized_copy(m.elem, m.elem + m.size(), elem);  //拷贝元素
    }
    
    template<typename T>
    Matrix& Matrix::operator=(const Matrix&m){
        
    	if(dim[0] != m.dim[0] || dim[1] != m.dim[1])
    		throw runtime_error("bad size in Matrix = ");
    	copym.elem, m.elem + m.size(), elem();  //拷贝元素
    }

**拷贝构造函数和拷贝赋值运算符的区别在于前者初始化一片未初始化的内存，而后者必须正确处理模板对象已经构造并可能拥有资源的情况**

Matrix的拷贝赋值运算符具有一个特性：如果拷贝某个元素时抛出了异常，则复制的模板对象就会被为旧值和新值混合的状态。即Matrix的赋值操作提供了基本保障，但未提供强制保障。如果我们认为这不可接收，可以用一种基本技术以避免该结果—首先创建一个副本，然后交换内容：

Matrix& Matrix::operator=(const Matrix&m){
        
    	Matrix tmp(m);  //创建副本
    	swap(tmp, *this);
    	return *this;
    }

只有当拷贝成功才会执行swap

一个拷贝构造函数通常需要拷贝每个非static成员。如果拷贝构造函数无法拷贝一个元素，它就会抛出一个异常。

注意拷贝构造函数的**自赋值问题**。

## 拷贝基类 ##

**当编写一个拷贝操作时，应该确保拷贝了每个基类和成员**。

从拷贝的目的来看，一个基类就是一个成员：为了拷贝派生类的一个对象，必须拷贝其基类

struct B1{
        
    	B1();
    	B1(const B1&);
    };
    
    struct B2{
        
    	B2();
    	B2(const B2&);
    };
    
    struct D : B1, B2{
        
    	D(int i): B1{
        }, B2{
        i}, m1{
        }, m2{
        2*i}{
        }
    	D(const D& a) : B1{
        a}, B2{
        a}, m1{
        a.m1}, m2{
        a.m2}{
        }
    	B1 m1;
    	B2 m2;
    };
    
    D d{
        1}
    D dd{
        d};  //拷贝构造

一个虚基类在类层次中可能作为多个类的基类。默认拷贝构造函数\[逐位拷贝\]能正确拷贝它。如果你自己定义拷贝构造函数，最简单的技术是重复拷贝虚基类。对于基类对象很小而且虚基类在类层次中只出现几次的情况来说，重复拷贝虚基类比试图避免重复拷贝更高效。

## 写前拷贝 ##

我们直到，之所以定义拷贝操作是为了避免浅拷贝。但是有时候浅拷贝有时有用-----写前拷贝： 在共享状态被修改之前，副本其实不具有真正的独立性，因此我们可以推迟共享状态的拷贝，直到首次修改副本前才真正进行拷贝。

class Image{
        
    public:
    	Image(const Image &a);
    	void write_block(Descriptor);
    private:
    	Representation * clone();
    	Representation * rep;
    	bool shared;
    };

假如一个Representation 可能很大，因此与检测bool值相比，write\_block()会很耗时。这是，我们可以用写前拷贝的技术：

Image::Image(const Image &a) : rep{
        a.rep}, shared(true){
        
    }
    
    void Image::write_block(Descriptor d){
        
    	if(shared){
        
    		req = clone();  //拷贝*req
    		shared = false;  //不再共享
    	}
    	// 现在我们可以安全的修改自己的副本了
    }

## 切片 ##

一个指向派生类的指针可以隐式转换为指向其公有基类的指针，这时拷贝很容易出错

struct Base{
        
    	int b;
    	Base(const Base&);
    };
    
    struct Derived : Base{
        
    	int d;
    	Derived (const Derived &);
    };
    
    
    void native(Base *p){
        
    	B b2 = *p;  //可能切片， 调用Base::Base(const Base&);
    	...
    }
    
    void user(){
        
    	Derived d;
    	native(&d);
    	Base bb = d; //切片，调用Base::Base(const Base&)而不是Derived::Derived(const Derived&);
    }

如果你不希望切片，可以采用以下方法防止这些现象

*  禁止拷贝基类：delete拷贝操作
 *  防止派生类指针转换为基类指针：将基类声明为private或者protect基类

# 移动 #

&&表示右值引用

移动赋值背后的思想是将左值的处理和右值的处理分离：拷贝赋值操作和拷贝构造函数接收左值，而移动赋值操作和移动构造函数接收右值。

template<typename T>
    Matrix<T>::Matrix(Matrix&& a)  
    			  : dim{
        a.dim}, elem{
        a.elem}{
        
    	a.dim = {
        0, 0};  
    	a.elem = nullptr;
    }

对于移动赋值操作，我们可以简单的进行一次交换。这种实现背后的思想是，源对象即将被销毁，因此我们可以让源对象的析构函数为我们做必要的清理工作

template<typename T>
    Matrix<T>& Matrix<T>::operator=(Matrix&a){
        
    	swap(dim, a.dim);
    	swap(elem, a.elem);
    }

移动构造函数和移动赋值运算符接收非const(右值)引用参数：它们可以修改参数。

移动操作通常不会抛出异常：它们不获取资源或者执行复杂操作，因此不需要抛出异常