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

最新推荐文章于 2024-07-31 12:23:22 发布

zwh1298454060

最新推荐文章于 2024-07-31 12:23:22 发布

阅读量892

点赞数 16

分类专栏： # 《Effective C++》文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/zwh1298454060/article/details/139394482

版权

《Effective C++》专栏收录该内容

21 篇文章 0 订阅

订阅专栏

文章目录

1、Terms14:Think carefully about copying behavior in resource-managing classes
2、总结
3、参考

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