使用holder进行内存管理

在C++中,我们使用new 和delete进行自己的内存管理.

void test_func()
{
    someType *ptr = new someType;

    //使用ptr
    ptr->function();

    delete ptr;
    ptr = nullptr;
}

函数开始创建一个对象,然后对其执行一些操作,最后销毁这个对象.看起来不错.不幸的是,如果在对象创建之后和销毁之前产生了一些错误,或者抛出了一个异常,那么这个对象将不会被释放,程序产生内存泄露.

当然,我们可以补抓异常,使用异常处理机制.不过现在要介绍的是另一种方法.

template <typename T>
class holder
{
public:
    holder() : m_ptr(nullptr){}

    explicit holder(T *p) : m_ptr(p) {}
    ~holder() { delete m_ptr; m_ptr = nullptr; }

    holder<T>& operator= (T *p)
    {
        delete m_ptr;
        m_ptr = p;

        return *this;
    }

    T& operator* () const { return *m_ptr; }
    T* operator-> () const { return m_ptr; }

    T* get() const { return m_ptr; }

    void release(){ m_ptr = nullptr; }

    void exchange_with(holder<T> &rhs)
    {
        swap(m_ptr, rhs->m_ptr);
    }

    void exchange_with(T *&p)
    {
        swap(m_ptr, p);
    }

private:
    holder(const holder<T> &);
    holder<T>& operator= (const holder<T> &);

private:
    T *m_ptr;
};

holder独占m_ptr所引用对象的所有权, 而且这个对象一定要用new操作来创建.

这样以来,我们原来的例子可以改为

void test_func()
{
    holder<someType> hd1(new someType);

    //使用ptr
    hd1->function();
}