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

条款十四：在资源管理类中小心copying行为

首先来看一个例子：

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

这个是模仿原书中的例子，做的一个加锁和解锁的操作。

运行结果如下：

#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 */

带删除器的MySharedPtr

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

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

最后总结一下：

复制RAII对象必须一并复制它所管理的资源，所以资源copying行为决定RAII对象的copying行为

普遍而常见的RAII class copying行为是：抑制copying，施行引用计数法（shared_ptr思想），或者是转移底部资源（auto_ptr思想）