《Effective C++》《资源管理——14、在资源管理类中小心copying行为》

本文主要是介绍《Effective C++》《资源管理——14、在资源管理类中小心copying行为》，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1、Terms14:Think carefully about copying behavior in resource-managing classes

条款13，引入了RAII原则，以此作为资源管理的一个原则。对于heap_based的资源，用auto_ptr，tr1::shared_ptr比较合适。但是对于非heap_based的资源，可能需要建立自己的资源管理类。
举一个栗子：

 #include <iostream>using namespace std;class Lock
{
public:explicit Lock(int* pm): m_p(pm){lock(m_p);}~Lock(){unlock(m_p);}private:int *m_p;void lock(int* pm){cout << "Address = " << pm << " is locked" << endl;}void unlock(int *pm){cout << "Address = " << pm << " is unlocked" << endl;}
};int main()
{int m = 5;Lock m1(&m);
}

这个是模仿原书中的例子，做的一个加锁和解锁的操作。
运行结果如下：

Address = 0x7ffc0820f6bc is locked
Address = 0x7ffc0820f6bc is unlocked...Program finished with exit code 0
Press ENTER to exit console.

这符合预期，当m1获得资源的时候，将之锁住，而m1生命周期结束后，也将资源的锁释放。
注意到Lock类中有一个指针成员，那么如果使用默认的析构函数、拷贝构造函数和赋值运算符，很可能会有严重的bug。
我们不妨在main函数中添加一句话，变成下面这样：

 int main()
{int m = 5;     Lock m1(&m);Lock m2(m1);
}

再次运行，可以看到结果：

Address = 0x7fffa98a14d4 is locked
Address = 0x7fffa98a14d4 is unlocked
Address = 0x7fffa98a14d4 is unlocked...Program finished with exit code 0
Press ENTER to exit console.

可见，锁被释放了两次，这就出问题了。原因是析构函数被调用了两次，在main()函数中生成了两个Lock对象，分别是m1和m2，Lock m2(m1)这句话使得m2.m_p = m1.m_p，这样这两个指针就指向了同一块资源。根据后生成的对象先析构的原则，所以m2先被析构，调用他的析构函数，释放资源锁，但释放的消息并没有通知到m1，所以m1在随后析构函数中，也会释放资源锁。
如果这里的释放不是简单的一句输出，而是真的对内存进行操作的话，程序就会崩溃。
归根到底，是程序使用了默认了拷贝构造函数造成的（当然，如果使用赋值运算的话，也会出现相同的bug），那么解决方案就是围绕如何正确摆平这个拷贝构造函数（和赋值运算符）。

方法一：禁止复制

很简单直观，就是干脆不让程序员使用类似于Lock m2(m1)这样的语句，一用就报编译错。这可以通过自己写一个私有的拷贝构造函数和赋值运算符的声明来解决。注意这里只要写声明就行了。
举个例子：

class Lock
{public:explicit Lock(int* pm): m_p(pm){lock(m_p);}~Lock(){unlock(m_p);}private:int *m_p;void lock(int* pm){cout << "Address = " << pm << " is locked" << endl;}void unlock(int *pm){cout << "Address = " << pm << " is unlocked" << endl;}private:Lock(const Lock&);Lock& operator= (const Lock&);
};

方法二：对底层资源使出“引用计数法”

就是使用shared_ptr来进行资源管理（见条款13），但还有一个问题，我想在生命周期结束后调用Unlock的方法，其实shared_ptr里面的删除器可以帮到我们。
举个栗子：

class Lock{public:explicit Lock(int *pm): m_p(pm, unlock){…}private:shared_ptr<int> m_p;}

这样在Lock的对象的生命周期结束后，就可以自动调用unlock了。
在条款十三的基础上，我改了一下自定义的shared_ptr，使之也支持删除器的操作了，
完整代码如下：

#ifndef MY_SHARED_PTR_H
#define MY_SHARED_PTR_H#include <iostream>
using namespace std;typedef void (*FP)();    template <class T>
class MySharedPtr
{private:T *ptr;size_t *count;FP Del; // 声明一个删除器static void swap(MySharedPtr& obj1, MySharedPtr& obj2){std::swap(obj1.ptr, obj2.ptr);std::swap(obj1.count, obj2.count);std::swap(obj1.Del, obj2.Del);}public:MySharedPtr(T* p = NULL): ptr(p), count(new size_t(1)),Del(NULL){}// 添加带删除器的构造函数MySharedPtr(T* p, FP fun): ptr(p), count(new size_t(1)), Del(fun){}MySharedPtr(MySharedPtr& p): ptr(p.ptr), count(p.count), Del(p.Del){++ *p.count;}MySharedPtr& operator= (MySharedPtr& p){if(this != &p && (*this).ptr != p.ptr){MySharedPtr temp(p);swap(*this, temp);}return *this;}~MySharedPtr(){if(Del != NULL){Del();}    reset();}T& operator* () const{return *ptr;}T* operator-> () const {return ptr;}T* get() const {return ptr;}void reset(){-- *count;if(*count == 0){delete ptr;ptr = 0;delete count;count = 0;//cout << "真正删除" << endl;}}bool unique() const{return *count == 1;}size_t use_count() const {return *count;}friend ostream& operator<< (ostream& out, const MySharedPtr<T>& obj){out << *obj.ptr;return out;}};#endif /* MY_SHARED_PTR_H */

方法三：复制底部资源

就是将原来的浅拷贝转换成深拷贝，需要自己显示定义拷贝构造函数和赋值运算符。这个也在之前的条款说过了，放到这里，其实就是在拷贝的时候对锁的计数次数进行+1，析构函数里就是对锁的计数次数进行-1，如果减到0就去unlock（其实思想还是类似于shared_ptr进行资源管理）

方法四：转移底部资源的拥有权

转移底部资源的控制权，这就是auto_ptr干的活了，在第二个方法中把shared_ptr换成auto_ptr就行了。

2、总结

天堂有路你不走，地狱无门你自来。

3、参考

3.1 《Effective C++》
3.2 读书笔记_Effective_C++_条款十四：在资源管理类中小心copying行为

这篇关于《Effective C++》《资源管理——14、在资源管理类中小心copying行为》的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---