c++之拷贝控制

引言

当定义一个类时，我们显式地或隐式地在此类型的对象拷贝、移动、复制和销毁时做什么。一个类通过定义五种特殊的成员函数来控制这些操作，包括：

• 拷贝构造函数
• 拷贝赋值运算符
• 移动构造函数
• 移动复制运算符
• 析构函数

拷贝与赋值

拷贝构造函数

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

拷贝构造函数的第一个参数必须是一个引用类型,虽然我们可以定义一个接受非const
引用的拷贝构造函数，但此参数几乎总是一个const的引用。拷贝构造函数在几种情况下都会被隐式地使用。因此，拷贝构造函数通常不应该是explicit的

拷贝复制运算符

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

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

三五法则

需要析构函数的类也需要拷贝和赋值操作

当我们决定一个类是否要定义它自己版本的拷贝控制成员时，一个基本原则是首先确定这个类是否需要一个析构函数。通常，对析构函数的需求要比拷贝构造函数或赋值运算符的需求更加明显。如果这个类需要一个析构函数，我们几乎肯定它也需要一个拷贝构造函数和一个拷贝复制运算符
（一个类有析构函数肯定是有分配在堆上的内存需要释放，那么如果不定义拷贝构造函数和拷贝复制运算符编译器就会调用合成版本导致浅拷贝，即多个对象指向同一个内存）

需要拷贝操作的类也需要复制操作，反之亦然

使用=default

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

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

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

阻止拷贝

虽然大多数类应该定义拷贝构造函数和拷贝赋值运算符，但对某些类来说，这些操作没有合理的意义。在此情况下，定义类时必须采用某种机制阻止拷贝或赋值。例如，iostream类阻止了拷贝，以避免多个对象写入或读取相同的IO缓冲。为了阻止拷贝，看起来可能应该不定义拷贝控制成员。但是，这种策略是无效的；如果我们的类未定义这些操作，编译器为它生成合成的版本。

定义删除的函数

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

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

析构函数不能是删除的成员

合成的拷贝控制成员可能是删除的

• 如果类的某个成员的析构函数是删除的或不可访问的(例如，是private的)，
  则类的合成析构函数被定义为删除的。
• 如果类的某个成员的拷贝构造函数是删除的或不可访问的，则类的合成拷贝构造函
  数被定义为删除的。如果类的某个成员的析构函数是删除的或不可访问的，则类合
  成的拷贝构造函数也被定义为删除的。
• 如果类的某个成员的拷贝赋值运算符是删除的或不可访问的，或是类有一个const
  的或引用成员，则类的合成拷贝赋值运算符被定义为删除的。
• 如果类的某个成员的析构函数是删除的或不可访问的，或是类有一个引用成员，它
  没有类内初始化器(参见2.6.1节，第65页)，或是类有一个const成员，它没有类内初始化器且其类型未显式定义默认构造函数,则该类的默认构造函数被定义为
  删除的。

定义行为像值的类

行为像值的类即每个对象之间没有关联，就跟值一样，如int类，string类等

class HasPtr{
public:
	HasPtr (const std: :string &s = std: :string()):ps(new std: :string(s))，i(0) {}
	//对ps指向的string，每个HasPtr对象都有自已的拷贝
	HasPtr (const HasPtr &p) :
	ps (new std: :string(*p.ps)), i(p.i) { }
	HasPtr& operator= (const HasPtr &) ;
	~HasPtr() { delete ps; }
private:
	std: :string *ps;
	int i;
};
HasPtr& HasPtr: :operator= (const HasPtr &rhs){
	auto newp = new string(*rhs.ps); // 拷贝底层string
	delete ps;
	// 释放旧内存
	ps = newp;
	/1从右侧运算对象拷贝数据到本对象
	i = rhs.i;
	return *this;   //返回本对象
}

定义行为像指针的类

行为像指针的类是多个对象共享底层数据，只有最后一个对象析构后底层数据才会释放。

对于行为类似指针的类，我们需要为定义拷贝构造函数和拷贝赋值运算符，来拷贝指针成员本身而不是它指向的数据。

令一个类展现类似指针的行为的最好方法是使用shared_ptr来管理类中的资源。拷贝（或赋值）一个shared_ptr会拷贝（赋值）shared_ptr所指向的指针。shared_ptr类自己记录有多少用户共享它所指向的对象。当没有用户使用对象时，shared_ptr类负责释放资源。

这里我们直接使用引用计数的方法定义一个类

class HasPtr{
public:
	//构造函数分配新的string和新的计数器，将计数器置为1
	HasPtr (const std: :string &s = std: :string()) :
	ps(new std: :string(s))，i(0)， use (new std: :size_t(1)) { }
	//拷贝构造函数拷贝所有三个数据成员，并递增计数器
	HasPtr (const HasPtr &p) :
	ps(p.ps)，i(p.i)， use(p.use) { ++*use; }
	HasPtr& operator= (const HasPtr&) ;
	~HasPtr () ;
private :
	std: :string *ps;
	int i;
	std::size_ t *use; //用来记录有多少个对象共享*ps的成员
};

HasPtr: :~HasPtr (){
	if (--*use == 0) { //如果引用计数变为0
		delete ps;
		//释放string内存
		delete use;
		//释放计数器内存
	}

HasPtr& HasPtr::operator= (const HasPtr &rhs)
{
	++*rhs.use; // 递增右侧运算对象的引用计数
	if (--*use == 0) { //然后递减本对象的引用计数
		delete ps;
		//如果没有其他用户
	delete use;
	//释放本对象分配的成员
	}
	ps = rhs.ps;
	// 将数据从 rhs拷贝到本对象
	i = rhs.i;
	use = rhs . use;
	return *this;
	//返回本对象
}

交换操作

除了定义拷贝控制成员，管理资源的类通常还定义一个名为swap的函数。

class HasPtr {
	friend void swap (HasPtr&，HasPtr&) ;
};
inline void swap (HasPtr &lhs， HasPtr &rhs){
	using std: : swap;
	swap (1hs.ps，rhs.ps) ;    // 交换指针， 而不是string数据
	swap(1hs.i, rhs.i) ;       //交换int成员
}

对象移动

新标准的一个最主要的特性是可以移动而非拷贝对象的能力。很多情况下都会发生对象拷贝。在其中某些情况下，对象拷贝后就立即被销毁了。在这些情况下，移动而非拷贝对象会大幅度提升性能。使用移动而不是拷贝的另一个原因源于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绑定到乘法结果上

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

• 所引用的对象将要被销毁
• 该对象没有其他用户

这两个特性意味着:使用右值引用的代码可以自由地接管所引用的对象的资源

标准库move函数

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

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

move调用高速编译器：我们有一个左值，但我们希望像一个右值一样处理它。我们必须认识到，调用move就意味着承诺：除了对rr1赋值或销毁它外，我们将不再使用它。在调用move之后，我们不能对移后源对象的值做任何假设。

移动构造函数和移动复制运算符

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

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

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

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