c++拷贝控制

https://blog.csdn.net/qq_43647628/article/details/106592995
类通过一些特殊的成员函数控制对象的拷贝，赋值，移动，销毁。包括：拷贝构造函数，拷贝赋值运算符，移动构造函数，移动赋值运算符，析构函数。
拷贝构造函数和移动构造函数定义当用同一类型对象初始化另一个时会发生什么；拷贝和移动赋值运算符定义了将一个对象赋予另一个对象时会发生什么；析构函数定义了当此类型对象销毁时会发生什么。
这些操作都为拷贝控制操作。
如果类没有定义，编译器会自动生成，但是可能导致错误的结果。

1.拷贝构造函数

一个构造函数第一个参数是自身类类型的引用，且额外参数都有默认值，则此构造函数是拷贝构造函数。

class Foo{
public:
	Foo();
	Foo(const Foo&);
};

拷贝构造函数被用来初始化非引用类类型参数，所以，如果其参数不是引用类型，那为了调用它就必须拷贝它的实参，但为了拷贝实参又要调用它，永远不会成功。
与此区分，构造函数还有：

class Complex 
{         

private :
    double m_real;
    double m_imag;

public:

    // 无参数构造函数
    // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
    // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
    Complex(void)
    {
         m_real = 0.0;
         m_imag = 0.0;
    } 
        
    // 一般构造函数（也称重载构造函数）
    // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
    // 例如：你还可以写一个 Complex( int num)的构造函数出来
    // 创建对象时根据传入的参数不同调用不同的构造函数
    Complex(double real, double imag)
    {
         m_real = real;
         m_imag = imag;         
     }
    
    // 复制构造函数（也称为拷贝构造函数）
    // 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
    // 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关 “浅拷贝” 、“深拷贝”的文章论述
    Complex(const Complex & c)
    {
        // 将对象c中的数据成员值复制过来
        m_real = c.m_real;
        m_img  = c.m_img;
    }            

    // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
    // 例如：下面将根据一个double类型的对象创建了一个Complex对象
    Complex::Complex(double r)
    {
        m_real = r;
        m_imag = 0.0;
    }

    // 等号运算符重载
    // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
    // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
    Complex &operator=(const Complex &rhs)
    {
        // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
        if ( this == &rhs ) 
        {
            return *this;
        }
            
        // 复制等号右边的成员到左边的对象中
        this->m_real = rhs.m_real;
        this->m_imag = rhs.m_imag;
            
        // 把等号左边的对象再次传出
        // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
        // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)    
        return *this;
    }
};

直接初始化是编译器根据函数匹配来选择与我们的参数最匹配的构造函数;
拷贝初始化要求编译器将右侧的对象拷贝到正在创建的对象中,如果需要还要进行类型转换。
拷贝构造函数被调用：
1.使用一个类的对象初始化该类的另一个新对象；

base s1; //构造函数
base s2(s1); //拷贝构造函数
base s3=s1; //拷贝构造函数
s1=s2; //赋值运算符

2.被调用函数形参是类的对象（值传递）；
3.函数返回值是类的对象时，函数执行完成返回时。

2.拷贝赋值运算符

class Foo{
	Foo& operator=(const Foo&);
}

s1=s2; //赋值运算符

赋值运算符通常应该返回一个指向左侧运算对象的引用。

3.析构函数

与构造函数相反，释放对象使用的资源，并销毁对象的非static数据成员。
没有返回值，不接受参数，不能被重载。
首先执行函数体，然后销毁成员，按照成员初始化顺序逆序销毁。析构函数体不直接销毁成员，成员是在函数体执行完后隐含的析构阶段销毁的。
销毁类类型成员需要执行成员自己的析构函数，销毁内置类型什么也不用做，但是销毁内置指针类型不会delete其所指向的对象。（智能指针是类）

“三五法则”

1.需要析构函数的类也需要拷贝和赋值操作
（一个类有析构函数肯定是有分配在堆上的内存需要释放，那么如果不定义拷贝构造函数和拷贝复制运算符编译器就会调用合成版本导致浅拷贝，即多个对象指向同一个内存）
2.需要拷贝操作的类也需要复制操作，反之亦然

我们可以通过将拷贝控制成员定义为=default来显示地要求编译器生成合成的版本

class Sales_ data{
public:
	//拷贝控制成员;使用default
	Sales_ data() = default;
	Sales_ data (const Sales_ data&) = default;
	Sales_ data& operator= (const Sales_ data &);
	~Sales_ data() = default;
	//其他成员的定义，如前
};

我们只能对具有合成版本的成员函数使用=default（即，默认构造函数或拷贝控制成员

定义删除的函数
在新标准下，我们可以通过将拷贝构造函数和拷贝赋值运算符定义为删除的函数来组织拷贝。删除的函数是这样一种函数：我们虽然声明了它们，但不能以任何方式使用它们。在函数的参数列表后面加上=delete来指出我们希望将它定义为删除的。

struct NoCopy{
	NoCopy() = default;
	NoCopy(const NoCopy&)  = delete;
	NoCopy &operator=(const NoCopy&) = delete; 
	~NoCopy() = default;
}

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

在某些情况下，对象拷贝后就立即被销毁了。在这些情况下，移动而非拷贝对象会大幅度提升性能。使用移动而不是拷贝的另一个原因源于IO类或unique_ptr这样的类。这些类都包含不能被共享的资源。因此，这些类型的对象不能拷贝但可以移动。

为了支持移动操作，新标准引入了一种新的引用类型——右值引用， **右值引用就是必须绑定到右值的引用。**通过&&而不是&来获得右值引用。

int i = 42;
int& r = i;            //正确: r引用i
int&& rr = i;          //错误:不能将一个右值引用绑定到一个左值上
int& r2 = i*42;        //错误: i*42是一个右值
const int &r3 = i*42;  //正确:我们可以将一个const的引用绑定到一个右值上
int&& rr2 = i*42;      //正确:将rr2绑定到乘法结果上

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

1. 所引用的对象将要被销毁
2. 该对象没有其他用户
   这两个特性意味着:使用右值引用的代码可以自由地接管所引用的对象的资源。

可通过调用一个名为move的新标准库函数来获得绑定到左值上的右值引用

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

调用move就意味着承诺：除了对rr1赋值或销毁它外，我们将不再使用它。

为了让我们自己的类型支持移动操作，需要为其定义移动构造函数和移动复制运算符，这两个成员类似对应的拷贝操作，但它们从给定对象“窃取”资源而不是拷贝资源。

StrVec: :StrVec (StrVec &&s) noexcept //移动操作不应抛出任何异常
//成员初始化器接管s中的资源
: elements (s.elements)， first_ free(s.first_ free)， cap(s. cap)
{
	//令s进入这样的状态一 对其运行析构函数是安全的
	s.elements = s.first_ free = s.cap = nullptr;
}

StrVec &StrVec: :operator= (StrVec &&rhs) noexcept
{
	//直接检测自赋值
	if (this != &rhs) {
		free() ;
		//释放已有元素:
		elements = rhs.elements; // 从rhs接管资源
		first_ free = rhs.first_ free;
		cap = rhs.cap;   //将rhs置于可析构状态
		rhs.elements = rhs.first_ free = rhs.cap = nullptr;
	}
	return *this;
}

由于移动操作“窃取"资源，它通常不分配任何资源。因此，移动操作通常不会抛出任何异常。当编写一个不抛出异常的移动操作时，我们应该将此事通知标准库。我们将看到，除非标准库知道我们的移动构造函数不会抛出异常，否则它会认为移动我们的类对象时可能会抛出异常，并且为了处理这种可能性而做一些额外的工作。

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