13.2拷贝控制和资源管理

通常，管理类外资源的类必须定义拷贝控制成员。这种类需要通过析构函数来释放对象所分配的资源，根据三五法则，需要析构函数的类也必须定义拷贝构造函数和拷贝赋值运算符。

我们先来看管理类型的对象的拷贝语义。一般来说有两种选择：

• 类的行为像一个值。意味着它应该也有自己的状态，当我们拷贝一个像值得对象时，副本和原对象是完全独立得。改变副本不会对原对象有任何影响，反之亦然。如string类，管理类外的字符串类型。
• 类的行为像一个指针。行为像指针得类则共享状态*。当我们拷贝一个这种类得对象时，副本和原对象使用相同的底层数据。改变副本也会改变对象，反之亦然。如shared_ptr类，管理类外指针指向的类型。*

我们以管理类外string数据的HasPtr为例进行说明，HasPtr数据成员如下：

class HasPtr {
public:
    //其他成员
private:
    int _i;
    string *_ps;
};

1.行为像值的类

为了使类的行为像一个值，对于类管理的资源，每个对象都应该拥有一份自己的拷贝。这意味着对于ps指向的string，每个HasPtr对象都得有自己的拷贝。因此，HasPtr需要：

• 定义一个拷贝构造函数，完成string的拷贝，而不是拷贝指针。
• 定义一个析构函数来释放string
• 定义一个拷贝赋值运算符来释放对象当前的string，并从右侧运算对象拷贝string。

类值版本的HasPtr如下：

class HasPtr {
public:
    HasPtr():_ps(new string), _i(0){}
    HasPtr(const HasPtr &p):_ps(new string(*p._ps)), _i(p._i) {}
    HasPtr& operator=(const HasPtr &rhs) {
        auto newp = new string(*rhs._ps);
        delete _ps;
        _ps = newp;
        _i = rhs._i;
        return *this;
    }
    ~HasPtr() {
        delete _ps;
    }
private:
    string *_ps;
    int _i;
};

①类值拷贝赋值运算符

赋值运算符通常组合了析构函数和构造函数的操作：

• 类似析构函数，赋值操作会销毁左侧运算对象的资源。
• 类似拷贝构造函数，赋值操作会从右侧运算对象拷贝数据。

注意这些操作要以正确的顺序执行。本例中，可以先通过拷贝右侧运算对象，来防止自赋值的情况，并保证异常发生时代码也是安全的。

②赋值运算符要防止自赋值的情况

自赋值就是如果将一个对象赋予其本身就是字符值，赋值运算符要保证自赋值情况发生时也能正确工作。

上述的拷贝赋值运算符代码可以保证自赋值安全的情况，下面的代码会导致错误：

HasPtr& operator=(const HasPtr &rhs) {
    delete ps;
    ps = new string(*(rhs.ps));
    i = rhs.i;
    return *this;
}

如果rhs和本对象是同一个对象，delete ps会释放*this和rhs指向的string，之后再对rhs.ps解引用时就会出错。

对于一个赋值运算符来说，正确工作是很重要的，即使把一个对象赋予它自身也能正确工作。为了防止自赋值出现错误，可以在销毁左侧运算对象资源之前拷贝右侧运算对象。

2.定义行为像指针的类

为了使类的行为指针的类， 我们需要为其定义拷贝构造函数和拷贝赋值运算符，来拷贝指针成员本身而不是它指向的string。 类仍需要析构函数来释放接受string参数的构造函数分配的动态内存，但是，析构函数只有当最后一个指向string的HasPtr对象销毁时，它才可以释放string。这时候使用引用计数就很有用了，我们不使用shared_ptr,而是设计自己的引用计数实现类似shared_ptr的功能。

①引用计数

引用计数的工作方式如下：

• 除了初始化对象外，每个构造函数（拷贝构造函数除外）还要创建一个引用计数，用来记录有多少对象正在创建的对象共享状态。当我们创建一个对象时，只有一个对象共享状态，因此将计数器初始化为1。
• 拷贝构造函数不分配新的计数器，而是拷贝给定对象的数据成员，包括计数器。拷贝构造函数递增共享的计数器，指出给定对象的状态又被一个新用户所共享。
• 析构函数递减计数器，指出共享状态的用户少了一个。如果计数器变为0，则析构函数释放状态。
• 拷贝赋值运算符递增右侧运算对象的计数器，递减左侧运算对象的计数器。如果左侧对象的计数器变为0，意味着它共享的状态没有用户了，拷贝赋值运算符就必须销毁状态。

计数器不能直接作为HasPtr的成员，应该保存在动态内存中。当创建一个对象，我们也分配一个新的计数器。当拷贝或赋值对象时，我们拷贝指向计数器的指针。

注意：就算构造函数（除了拷贝构造函数）创建的两个对象各个参数都一样，它们也是不同的对象，因此只有拷贝构造函数和拷贝赋值运算符才会共享状态。

②定义一个使用引用计数的类

实现类似shared_ptr<string>的功能的类HasPtr。

class HasPtr {
public:
    HasPtr():_ps(new string), _i(0), _use(new int(1)) {}
    //拷贝构造函数拷贝所有成员，并递增计数器
    HasPtr(const HasPtr &rhs):
    _ps(rhs._ps), _i(rhs._i), _use(rhs._use) {
        ++*_use;
    }
    HasPtr& operator=(const HasPtr &rhs) {
        ++*rhs._use;
        if (--*_use == 0) {
            delete _ps;
            delete _use;
        } 
        _ps = rhs._ps;
        _i = rhs._i;
        _use = rhs._use;
        return *this;
    }
    ~HasPtr() {
        if (--*_use == 0) {
            delete _ps;
            delete _use;
        }
    }
private:
    string *_ps;
    int _i;
    int *_use; //用来记录有多少个对象共享*ps成员
};

③类指针的拷贝成员“篡改”引用计数

• 当拷贝或赋值一个HasPtr对象时，副本和原对象共享相同的string，即拷贝_ps指针本身，并递增该string关联的计数器。
• 析构函数先递减计数器，再判断如果计数器等于0，释放掉管理的string对象。
• 拷贝赋值运算符需要递增右侧运算符对象的引用计数，递减左侧运算符对象的引用计数，如果引用计数的值是0，则析构掉左侧对象。

3.交换操作

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

对于那些与重排元素顺序的算法一起使用的类，定义swap非常重要，这类算法在需要交换两个元素时会调用swap。

如果一个类定义了自己的swap，那么算法将使用类自定义的swap，否则将使用标准库使用的swap。

②编写HashPtr的swap函数

可以在我们的类上定义一个自己版本的swap来重载swap的默认行为。实现如下：

class HasPtr {
    friend void swap(HasPtr &, HasPtr &);
    //其他成员函数定义与行为像值的HasPtr一样
}
inlie
    void swap(HasPtr &lhs, HasPtr &rhs) {
    using std::swap;      //调用标准库的swap
    swap(lhs.ps, rhs.ps); //交换指针而不是string数据
    swap(lhs.i, rhs.i);   //交换int成员
}

由于内置类型没有特定版本的swap，因此我们HasPtr的swap函数中调用的swap是标准库中的swap。

但是如果一个类成员有自己的swap函数，那么调用标准库的swap就是浪费的。标准库中的swap会进行值得拷贝进行不必要的拷贝。

③在赋值运算符中使用swap

定义swap的类通常使用swap来定义它们的赋值运算符。这些运算符使用了一种名为拷贝并交换的技术。这种技术将左侧运算对象与右侧运算对象的一个副本进行交换（我们为了防止自赋值出现问题，也是在左侧运算符销毁之前先对右侧运算符进行拷贝）：

HasPtr& operator=(HasPtr rhs) {
	swap(*this, rhs);
	return *this;
}

//原本的赋值运算符
HasPtr& operator=(const HasPtr &rhs) {
	auto newp = new string(*rhs._ps);
	delete _ps;
	_ps = newp;
	_i = rhs._i;
	return *this;
}

用swap版本的赋值运算符中，参数是以值传递的方式进行的，因此，rhs是右侧运算符的一个副本，将左侧运算对象与右侧运算对象的一个副本进行交换，将副本和左侧运算对象的_ps和i的值进行交换，运算符调用结束后，rhs被销毁，HasPtr的析构函数将执行，销毁rhs现在指向的内存，即左侧运算符对象原来的内存。

这个技术的有趣地方就在于自动处理了自赋值的情况，天然就是安全的。