通常,管理类外资源的类必须定义拷贝控制成员。这种类需要通过析构函数来释放对象所分配的资源,根据三五法则,需要析构函数的类也必须定义拷贝构造函数和拷贝赋值运算符。
我们先来看管理类型的对象的拷贝语义。一般来说有两种选择:
- 类的行为像一个值。意味着它应该也有自己的状态,当我们拷贝一个像值得对象时,副本和原对象是完全独立得。改变副本不会对原对象有任何影响,反之亦然。如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现在指向的内存,即左侧运算符对象原来的内存。
这个技术的有趣地方就在于自动处理了自赋值的情况,天然就是安全的。