在作用域结束时自动执行某个函数

假设有这样一个函数,这个函数里有多个if分支，每个if分支里都有return；
如果在这个函数return之前，我们需要销毁某个对象，
那么我们需要在每个if分支里面添加销毁这个对象的代码。
如果我们合理的利用对象的生命周期，那么我们就可以在对象析构时做一些事情,比如调用某个外界函数。

为了实现这一点我编写了一个类：CDestructorRunner

头文件：DestructorRunner.h

/**************************************************************************
file: DestructorRunner.h
class: CDestructorRunner 

     析构函数运行器：当CDestructorRunner对象生命周期结束时，它的析构函数调用它在初始化
        时被指定的回调函数

remark:
   
   CDestructorRunner提供4种方式的类重载.
   1. 生命周期结束时，调用某个对象的成员函数(函数带一个参数)
   2. 生命周期结束时，调用某个对象的成员函数(函数无参数)
   3. 生命周期结束时，调用某个普通函数(函数带一个参数)
   4. 生命周期结束时，调用某个普通函数(函数无参数)

date: 2011-5-18
writer: guoxuxing

mail: gemeryguo@126.com
***************************************************************************/

#pragma once

template<class TClass,typename TResult,typename TParam>
class CDestructorRunner
{
    // 析构时，调用某个对象的函数(函数具备一个参数)
public:
    typedef TResult (TClass::*Function)(TParam);

    CDestructorRunner(Function callback,TParam param,TClass *pClassObj):
    m_callback(callback),m_pClassObj(pClassObj),m_param(param)
    {

    }
    ~CDestructorRunner()
    {
        (m_pClassObj->*m_callback)(m_param);
    }

    Function m_callback;
    TClass *m_pClassObj;
    TParam m_param;
};
template<class TClass,typename TResult>
class CDestructorRunner<TClass,TResult,void>
{
    // 析构时，调用某个对象的函数(函数无参数)
public:
    typedef TResult (TClass::*Function)(void);

    CDestructorRunner(Function callback,TClass *pClassObj):
    m_callback(callback),m_pClassObj(pClassObj)
    {

    }
    ~CDestructorRunner()
    {
        (m_pClassObj->*m_callback)();
    }

    Function m_callback;
    TClass *m_pClassObj;
};

template<typename TResult,typename TParam>
class CDestructorRunner<void,TResult,TParam>
{
    // 析构时，调用一个普通函数
public:
    typedef TResult(*Function)(TParam);
    CDestructorRunner(Function callback,TParam param):
    m_callback(callback),m_param(param)
    {

    }
    ~CDestructorRunner()
    {
        (m_callback)(m_param);
    }

    Function m_callback;
    TParam m_param;
};

template<typename TResult>
class CDestructorRunner<void,TResult,void>
{
    // 析构时，调用一个普通函数
public:
    typedef TResult(*Function)(void);
    CDestructorRunner(Function callback):
    m_callback(callback)
    {

    }
    ~CDestructorRunner()
    {
        (m_callback)();
    }

    Function m_callback;
};

测试例子:调用Func

void Delete(int *pA)
{
    delete pA;
}
void Func()
{
    int *p = new int(10);

    // 自定释放函数为：Delete, p指向的内存会自动释放
    CDestructorRunner<void,void,int*> drDelInt(Delete,p); 

    if (*p==1)
    {
        //delete p;
        return;
    }
    if (*p==2)
    {
        //delete p;
        return;
    }
    if (*p==3)
    {
        //delete p;
        return;
    }
    if (*p==4)
    {
        //delete p;
        return;
    }
    if (*p==5)
    {
        //delete p;
        return;
    }
    if (*p==6)
    {
        //delete p;
        return;
    }
    if (*p==10)
    {
        //delete p;
        return;
    }
}

使用 CDestructorRunner类可以省去很多代码的书写,也不至于在某个分支里面忘记释放内存并造成内存泄露.

使用时，也可以为CDestructorRunner指定某个类的成员函数，需要这个类的某个对象指针。

 

void EmptyStr(CString& str)
{
    // str被清空了
    CDestructorRunner<CString,void,void> drEmptyString(CString::Empty,&str); 
}