EffectiveC++学习笔记-条款14

条款14 在资源管理类中小心coping行为

例如我们现在要处理一个Mutex互斥的对象，有lock和unlock使用。

void lock(Mutex* pm);void unlock(Mutex* pm);

然后建立一个class用来管理锁。

class Lock{public:    explicit Lock(Mutex* pm):mutexPtr(pm)    {        lock(mutexPtr);//获取资源    }    ~Lock()    {        unlock(mutexPtr)//释放资源    }private:    Mutex mutexPtr;

我们这样就可以放心使用Lock了。

现在的问题是当我们Lock对象被复制会发生什么。

Lock m1(&m);Lock m2 = m1;

我们有两种或者更多其他选择：

1. 禁止复制
   class Lock : private Uncopyable{};

2. 使用引用计数法
   我们可以使用tr1::shared_ptr< Mutex >但是引用次数为0它将删除Mutex，而我们需要的是解除锁定。

幸运的是shared_ptr可以指定“删除器”也就是引用次数为0时被调用。

class Lock{    //指定删除器为 unlock    explicit Lock(Mutex* pm):mutexPtr(pm,unlock)    {        lock(mutexPtr);    }private:    std::tr1::shared_ptr<Mutex> mutexPtr;}

这样就不需要声明析构函数了。

实现一个仿函数

其实那个删除器的名字又称为仿函数。
仿函数是什么？
不是函数但可以像函数一样使用，因为重载了operator()
例如

//定制仿函数template<class T>struct Less{    //T类型必须实现了operator<运算符    bool operator()(const T& l, const T& r)    {        return l < r;    }};

下面我们实现一个带有删除器的智能指针

template<class T>//注意这里有模版  默认new申请内存释放struct Del{    void operator()(const T* ptr)    {        delete ptr;    }};struct Free//注意这里没有模版  对应malloc申请内存{    void operator()(void* ptr)    {        free(ptr);    }};//带有默认删除器 Deltemplate<class T, class Deleter = Del<T>>class SharedPtr{public:    SharedPtr(T* ptr, Deleter del) :        m_ptr(ptr),        m_count(new long(1)),        m_del(del)  {}    SharedPtr(T* ptr):        m_ptr(ptr),        m_count(new long(1)) {}    ~SharedPtr()    {        release();    }protected:    void release()    {        if(--*m_count == 0)        {            m_del(m_ptr);            delete m_count;            m_count = nullptr;                    cout <<"del"<<endl;        }    }private:    T*      m_ptr;    long*   m_count;    Deleter m_del;};void test(){    SharedPtr<int>sp1(new int(1));    SharedPtr<int,Free>sp2((int*)malloc(sizeof(int) * 10), Free());//注意怎么调用的}

完成！