C++实现的委托机制(2)

1.实现任意参数的函数委托

按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？

注：最终的实现代码可以在这里下载： 
// 单参函数委托
template
class CMultiDelegate1{};
// 双参函数委托
template
class CMultiDelegate2{};

注意类名是不一样的，分别为CMultiDelegate1和CMultiDelegate2

C++里面，类名相同但模板参数个数不同是会当成一个类对待的，所以那样编译不过的

这样是不是很麻烦呢？

不是很麻烦，是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本

连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本！

其实所有版本的内部实现几乎一样，下面给出双参函数的版本

template 
class IDelegate2 
{ 
public: 
    virtual ~IDelegate2() { } 
    virtual bool isType( const std::type_info& _type) = 0; 
    virtual void invoke( TP1 p1, TP2 p2 ) = 0; 
    virtual bool compare( IDelegate2 *_delegate) const = 0; 
}; 
template 
class CStaticDelegate2 : public  IDelegate2 
{ 
public: 
    typedef void (*Func)( TP1 p1, TP2 p2 ); 
    CStaticDelegate2 (Func _func) : mFunc(_func) { } 
    virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2 ) == _type; } 
    virtual void invoke( TP1 p1, TP2 p2 ) 
    { 
        mFunc( p1, p2 ); 
    } 
    virtual bool compare( IDelegate2 *_delegate) const 
    { 
        if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 )) ) return false; 
        CStaticDelegate2 * cast = static_cast *>(_delegate); 
        return cast->mFunc == mFunc; 
    } 
    virtual bool compare(IDelegateUnlink * _unlink) const { return false; } 
private: 
    Func mFunc; 
}; 
template  
class CMethodDelegate2 : public  IDelegate2  
{ 
public: 
    typedef void (T::*Method)( TP1 p1, TP2 p2 ); 
    CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { } 
    virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 ) == _type; } 
    virtual void invoke( TP1 p1, TP2 p2 ) 
    { 
        (mObject->*mMethod)( p1, p2 ); 
    } 
    virtual bool compare(  IDelegate2   * _delegate) const 
    { 
        if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 )) ) return false; 
        CMethodDelegate2   * cast = static_cast<  CMethodDelegate2   * >(_delegate); 
        return cast->mObject == mObject && cast->mMethod == mMethod; 
    } 
private: 
    T * mObject; 
    Method mMethod; 
}; 
template    
inline  delegates::IDelegate2   * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) ) 
{ 
    return new delegates::CStaticDelegate2   (_func); 
} 
template  
inline  delegates::IDelegate2   * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) ) 
{ 
    return new delegates::CMethodDelegate2    (_object, _method); 
} 
template    
class CMultiDelegate2 
{ 
public: 
    typedef IDelegate2   IDelegate; 
    typedef typename std::list ListDelegate; 
    typedef typename ListDelegate::iterator ListDelegateIterator; 
    typedef typename ListDelegate::const_iterator ConstListDelegateIterator; 
    CMultiDelegate2 () { } 
    ~CMultiDelegate2 () { clear(); } 
    bool empty() const 
    { 
        for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter) 
        { 
            if (*iter) return false; 
        } 
        return true; 
    } 
    void clear() 
    { 
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter) 
        { 
            if (*iter) 
            { 
                delete (*iter); 
                (*iter) = 0; 
            } 
        } 
    } 
    CMultiDelegate2  & operator+=(IDelegate* _delegate) 
    { 
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter) 
        { 
            if ((*iter) && (*iter)->compare(_delegate)) 
            { 
                delete _delegate; 
                return *this; 
                //MYGUI_ASSERT(false, "dublicate delegate");  
            } 
        } 
        mListDelegates.push_back(_delegate); 
        return *this; 
    } 
    CMultiDelegate2  & operator-=(IDelegate* _delegate) 
    { 
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter) 
        { 
            if ((*iter) && (*iter)->compare(_delegate)) 
            { 
                if ((*iter) != _delegate) delete (*iter); 
                (*iter) = 0; 
                break; 
            } 
        } 
        delete _delegate; 
        return *this; 
    } 
    void operator()( TP1 p1, TP2 p2 ) 
    { 
        ListDelegateIterator iter = mListDelegates.begin(); 
        while (iter != mListDelegates.end()) 
        { 
            if (0 == (*iter)) 
            { 
                iter = mListDelegates.erase(iter); 
            } 
            else 
            { 
                (*iter)->invoke( p1, p2 ); 
                ++iter; 
            } 
        } 
    } 
private: 
    CMultiDelegate2 (const CMultiDelegate2  & _event); 
    CMultiDelegate2 & operator=(const CMultiDelegate2 & _event); 
private: 
    ListDelegate mListDelegates; 
}; 
template
class IDelegate2
{
public:
    virtual ~IDelegate2() { }
    virtual bool isType( const std::type_info& _type) = 0;
    virtual void invoke( TP1 p1, TP2 p2 ) = 0;
    virtual bool compare( IDelegate2 *_delegate) const = 0;
};
template
class CStaticDelegate2 : public  IDelegate2
{
public:
    typedef void (*Func)( TP1 p1, TP2 p2 );
    CStaticDelegate2 (Func _func) : mFunc(_func) { }
    virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2 ) == _type; }
    virtual void invoke( TP1 p1, TP2 p2 )
    {
        mFunc( p1, p2 );
    }
    virtual bool compare( IDelegate2 *_delegate) const
    {
        if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 )) ) return false;
        CStaticDelegate2 * cast = static_cast *>(_delegate);
        return cast->mFunc == mFunc;
    }
    virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
private:
    Func mFunc;
};
template
class CMethodDelegate2 : public  IDelegate2
{
public:
    typedef void (T::*Method)( TP1 p1, TP2 p2 );
    CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
    virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 ) == _type; }
    virtual void invoke( TP1 p1, TP2 p2 )
    {
        (mObject->*mMethod)( p1, p2 );
    }
    virtual bool compare(  IDelegate2   * _delegate) const
    {
        if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 )) ) return false;
        CMethodDelegate2   * cast = static_cast<  CMethodDelegate2   * >(_delegate);
        return cast->mObject == mObject && cast->mMethod == mMethod;
    }
private:
    T * mObject;
    Method mMethod;
};
template  
inline  delegates::IDelegate2   * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) )
{
    return new delegates::CStaticDelegate2   (_func);
}
template
inline  delegates::IDelegate2   * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) )
{
    return new delegates::CMethodDelegate2    (_object, _method);
}
template  
class CMultiDelegate2
{
public:
    typedef IDelegate2   IDelegate;
    typedef typename std::list ListDelegate;
    typedef typename ListDelegate::iterator ListDelegateIterator;
    typedef typename ListDelegate::const_iterator ConstListDelegateIterator;
    CMultiDelegate2 () { }
    ~CMultiDelegate2 () { clear(); }
    bool empty() const
    {
        for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
            if (*iter) return false;
        }
        return true;
    }
    void clear()
    {
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
            if (*iter)
            {
                delete (*iter);
                (*iter) = 0;
            }
        }
    }
    CMultiDelegate2  & operator+=(IDelegate* _delegate)
    {
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
            if ((*iter) && (*iter)->compare(_delegate))
            {
                delete _delegate;
                return *this;
                //MYGUI_ASSERT(false, "dublicate delegate");
            }
        }
        mListDelegates.push_back(_delegate);
        return *this;
    }
    CMultiDelegate2  & operator-=(IDelegate* _delegate)
    {
        for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
            if ((*iter) && (*iter)->compare(_delegate))
            {
                if ((*iter) != _delegate) delete (*iter);
                (*iter) = 0;
                break;
            }
        }
        delete _delegate;
        return *this;
    }
    void operator()( TP1 p1, TP2 p2 )
    {
        ListDelegateIterator iter = mListDelegates.begin();
        while (iter != mListDelegates.end())
        {
            if (0 == (*iter))
            {
                iter = mListDelegates.erase(iter);
            }
            else
            {
                (*iter)->invoke( p1, p2 );
                ++iter;
            }
        }
    }
private:
    CMultiDelegate2 (const CMultiDelegate2  & _event);
    CMultiDelegate2 & operator=(const CMultiDelegate2 & _event);
private:
    ListDelegate mListDelegates;
};

当然放心啦，不会让大家将不同参数的版本各写一遍的

下面要介绍的是MyGUI的解决方法，一个利用预编译和头文件重复编译的方法（很有意思的）

我们一般写头文件时，都会加上防止头文件重复编译的代码，如

__XXX_H__  
#define __XXX_H__  
// ..类声明等  
#endif 
#ifndef __XXX_H__
#define __XXX_H__
// ..类声明等
#endif

这里我们就要反其道而行，去掉防止重复编译的代码，然后重复包含这个头文件，但每次其编译的都是不同参数个数的版本

第一次编译的是无参的，第二次是单参的，第三次是双参.....一直到你想要支持的参数个数

那怎么让其每次编译的都不同呢？

答案就是使用强大的预编译：宏

下面给出单参的IDelegate的例子

首先定义以下宏：
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS
#define DELEGATE_TEMPLATE_ARGS TP1 p1
#define MYGUI_I_DELEGATE IDelegate1

那么下面这段代码就会编译出单参的IDelegate版本
DELEGATE_TEMPLATE   DELEGATE_TEMPLATE_PARAMS
class MYGUI_I_DELEGATE
{
public:
    virtual ~MYGUI_I_DELEGATE() { }
    virtual bool isType( const std::type_info& _type) = 0;
    virtual void invoke( DELEGATE_PARAMS ) = 0;
    virtual bool compare(  MYGUI_I_DELEGATE DELEGATE_TEMPLATE_ARGS  * _delegate) const = 0;
};

神奇吧，这里使用的可以说是宏实现的多态。

在这段代码编译完了之后，将所有宏都undefine掉，如
#undef DELEGATE_TEMPLATE
#undef DELEGATE_TEMPLATE_PARAMS
#undef DELEGATE_TEMPLATE_ARGS
#undef MYGUI_I_DELEGATE

再重新定义双参版本的，如
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS
#define DELEGATE_TEMPLATE_ARGS TP1 p1, TP2 p2
#define MYGUI_I_DELEGATE IDelegate2

那么编译出来的就是双参的版本了！

使用这种方法就可以将其他的如CStaticDelegate、CMethodDelegate和CMultiDelegate的各种版本都实现了，

而你要做的仅是重新define下那些宏就行了，够方便了吧。

下一篇文章将会介绍MyGUI实现的一些辅助类，如单委托和DelegateUnlink。并给出一个测试例子，测试该委托机制对C++各种函数的支持。

 摘自：gouki04的专栏