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

1.引言

按上一篇文章的方法，你已经可以使用任意参数的函数委托了。这里介绍下MyGUI实现的两个辅助类，CDelegate类和 IDelegateUnlink。如果你不为了深入了解MyGUI的委托实现，可以跳过此处。CDelegate即为单委托，实际效果跟函数指针差不多， 于CMultiDelegate的区别在于其不支持多播。而IDelegateUnlink类主要是在CMultiDelegate中使用，在多播下一次 性去掉自身的所有委托。

2.单委托
// 无参的单委托实现  
class CDelegate 
{ 
public: 
    typedef CDelegate IDelegate; 
 
 
    CDelegate () : mDelegate(0) { } 
    CDelegate (const CDelegate& _event) 
    { 
        // 在拷贝构造时，将被拷贝的委托去掉，即委托只存在一份  
        mDelegate = _event.mDelegate; 
        const_cast(_event).mDelegate = 0; 
    } 
    ~CDelegate () { clear(); } 
 
 
    bool empty() const { return mDelegate == 0; } 
 
 
    void clear() 
    {  
        if (mDelegate) 
        { 
            delete mDelegate; 
            mDelegate = 0; 
        } 
    } 
 
 
    CDelegate & operator=(IDelegate* _delegate) 
    { 
        delete mDelegate; 
        mDelegate = _delegate; 
        return *this; 
    } 
 
 
    CDelegate & operator=(const CDelegate& _event) 
    { 
        // 在赋值时，将右值的委托去掉，即委托只存在一份  
        delete mDelegate; 
        mDelegate = _event.mDelegate; 
        const_cast(_event).mDelegate = 0; 
 
 
        return *this; 
    } 
 
 
    void operator()( ) 
    { 
        if (mDelegate == 0) return; 
        mDelegate->invoke( ); 
    } 
 
 
private: 
    IDelegate * mDelegate; 
}; 
// 无参的单委托实现
class CDelegate
{
public:
    typedef CDelegate IDelegate;

    CDelegate () : mDelegate(0) { }
    CDelegate (const CDelegate& _event)
    {
        // 在拷贝构造时，将被拷贝的委托去掉，即委托只存在一份
        mDelegate = _event.mDelegate;
        const_cast(_event).mDelegate = 0;
    }
    ~CDelegate () { clear(); }

    bool empty() const { return mDelegate == 0; }

    void clear()
    {
        if (mDelegate)
        {
            delete mDelegate;
            mDelegate = 0;
        }
    }

    CDelegate & operator=(IDelegate* _delegate)
    {
        delete mDelegate;
        mDelegate = _delegate;
        return *this;
    }

    CDelegate & operator=(const CDelegate& _event)
    {
        // 在赋值时，将右值的委托去掉，即委托只存在一份
        delete mDelegate;
        mDelegate = _event.mDelegate;
        const_cast(_event).mDelegate = 0;

        return *this;
    }

    void operator()( )
    {
        if (mDelegate == 0) return;
        mDelegate->invoke( );
    }

private:
    IDelegate * mDelegate;
};可以看到，单委托只实现了 = 运算符，没有实现 += 运算符。
而且在赋值时会将原委托去掉，确保只有一份委托。
其实单委托跟普通函数指针差不多，在使用单委托的地方可以换成使用普通函数指针。

3.断开委托
// 断开委托的基类  
class IDelegateUnlink 
{ 
public: 
    virtual ~IDelegateUnlink() { } 
 
 
    IDelegateUnlink() { m_baseDelegateUnlink = this; } 
    bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; } 
 
 
private: 
    IDelegateUnlink * m_baseDelegateUnlink; 
}; 
// 断开委托的基类
class IDelegateUnlink
{
public:
    virtual ~IDelegateUnlink() { }

    IDelegateUnlink() { m_baseDelegateUnlink = this; }
    bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; }

private:
    IDelegateUnlink * m_baseDelegateUnlink;
};所谓断开委托，只能用在多重委托，即CMultiDelegate中，可以断开自身与其相连的所有委托。
使用方法就在将自身的类从IDelegateUnlink派生，然后使用CMultiDelegate中的clear函数即可断开委托。
在下面会有例子说明。

4.测试

/* 测试Delegate对不同函数的支持
 * 可以参考下不同函数的使用方式
 */ 
#include "delegate.h"  
#include   
 
 
using namespace std; 
 
 
// 普通函数1  
void func(int a, int b) 
{ 
    cout << "func(" << a << ", " << b << ")" << endl; 
} 
 
 
// 普通函数2  
void func2(int a, int b) 
{ 
    cout << "func2(" << a << ", " << b << ")" << endl; 
} 
 
 
// 普通类  
class NormalClass 
{ 
public: 
    // 类的普通成员函数  
    void normalFunc(int a, int b) 
    { 
        cout << "NormalClass::normalFunc(" << a << ", " << b << ")" << endl; 
    } 
}; 
 
 
// 实现了IDelegateUnlink的类  
class BaseUnlinkClass : public delegates::IDelegateUnlink 
{ 
public: 
    // 类的虚函数  
    virtual void virFunc(int a, int b) 
    { 
        cout << "BaseUnlinkClass::virFunc(" << a << ", " << b << ")" << endl; 
    } 
 
 
    // 类的普通成员函数  
    void normalFunc(int a, int b) 
    { 
        cout << "BaseUnlinkClass::normalFunc(" << a << ", " << b << ")" << endl; 
    } 
}; 
 
 
class DerivedClass : public BaseUnlinkClass 
{ 
public: 
    // 类的虚函数  
    virtual void virFunc(int a, int b) 
    { 
        cout << "DerivedClass::virFunc(" << a << ", " << b << ")" << endl; 
    } 
 
 
    // 类的静态成员函数  
    static void staticFunc(int a, int b) 
    { 
        cout << "DerivedClass::staticFunc(" << a << ", " << b << ")" << endl; 
    } 
}; 
 
 
// 模板函数  
template 
void TFunc(T a, T b) 
{ 
    cout << "TFunc(" << a << ", " << b << ")" << endl; 
} 
 
 
int main() 
{ 
    BaseUnlinkClass *baseUnlinkClass = new BaseUnlinkClass; 
    DerivedClass *derivedClass = new DerivedClass; 
    NormalClass *normalClass = new NormalClass; 
     
    // 定义委托  
    typedef delegates::CMultiDelegate2 EvenetHandler; 
    EvenetHandler event; 
 
 
    // 添加普通函数  
    event += newDelegate(func); 
    event += newDelegate(func2); 
 
 
    // 添加类的普通成员函数  
    event += newDelegate(normalClass, &NormalClass::normalFunc); 
    event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::normalFunc); 
 
 
    // 添加类的虚函数  
    event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::virFunc); 
    event += newDelegate(derivedClass, &DerivedClass::virFunc); 
    // 注意在多态下，使用基类指针时，函数指针要用基类的函数指针，不能用派生类的  
    // 但是在调用时会响应多态，也就是会调用派生类的虚函数  
    event += newDelegate((BaseUnlinkClass*)derivedClass, &BaseUnlinkClass::virFunc); 
 
 
    // 添加类的静态成员函数  
    event += newDelegate(&DerivedClass::staticFunc); 
 
 
    // 添加模板函数  
    event += newDelegate(TFunc); 
     
    // 触发事件  
    event(1, 2); 
    cout << endl; 
 
 
    // 去掉函数  
    event -= newDelegate(func); 
 
 
    // 去掉baseUnlinkClass所有的函数  
    event.clear(baseUnlinkClass); 
 
 
    // 去掉derivedClass所有的函数  
    // 注意静态成员函数staticFunc不会去掉  
    event.clear(derivedClass); 
 
 
    //event.clear(normalClass);  
    // 错误调用，normalClass不是IDelegateUnlink的派生类  
    // 不能使用clear去掉自身的函数  
    // 应该使用如下方法  
    event -= newDelegate(normalClass, &NormalClass::normalFunc); 
     
    // 触发事件  
    event(2, 3); 
    cout << endl; 
 
 
    return 0; 
} 
/* 测试Delegate对不同函数的支持
 * 可以参考下不同函数的使用方式
 */
#include "delegate.h"
#include

using namespace std;

// 普通函数1
void func(int a, int b)
{
    cout << "func(" << a << ", " << b << ")" << endl;
}

// 普通函数2
void func2(int a, int b)
{
    cout << "func2(" << a << ", " << b << ")" << endl;
}

// 普通类
class NormalClass
{
public:
    // 类的普通成员函数
    void normalFunc(int a, int b)
    {
        cout << "NormalClass::normalFunc(" << a << ", " << b << ")" << endl;
    }
};

// 实现了IDelegateUnlink的类
class BaseUnlinkClass : public delegates::IDelegateUnlink
{
public:
    // 类的虚函数
    virtual void virFunc(int a, int b)
    {
        cout << "BaseUnlinkClass::virFunc(" << a << ", " << b << ")" << endl;
    }

    // 类的普通成员函数
    void normalFunc(int a, int b)
    {
        cout << "BaseUnlinkClass::normalFunc(" << a << ", " << b << ")" << endl;
    }
};

class DerivedClass : public BaseUnlinkClass
{
public:
    // 类的虚函数
    virtual void virFunc(int a, int b)
    {
        cout << "DerivedClass::virFunc(" << a << ", " << b << ")" << endl;
    }

    // 类的静态成员函数
    static void staticFunc(int a, int b)
    {
        cout << "DerivedClass::staticFunc(" << a << ", " << b << ")" << endl;
    }
};

// 模板函数
template
void TFunc(T a, T b)
{
    cout << "TFunc(" << a << ", " << b << ")" << endl;
}

int main()
{
    BaseUnlinkClass *baseUnlinkClass = new BaseUnlinkClass;
    DerivedClass *derivedClass = new DerivedClass;
    NormalClass *normalClass = new NormalClass;
   
    // 定义委托
    typedef delegates::CMultiDelegate2 EvenetHandler;
    EvenetHandler event;

    // 添加普通函数
    event += newDelegate(func);
    event += newDelegate(func2);

    // 添加类的普通成员函数
    event += newDelegate(normalClass, &NormalClass::normalFunc);
    event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::normalFunc);

    // 添加类的虚函数
    event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::virFunc);
    event += newDelegate(derivedClass, &DerivedClass::virFunc);
    // 注意在多态下，使用基类指针时，函数指针要用基类的函数指针，不能用派生类的
    // 但是在调用时会响应多态，也就是会调用派生类的虚函数
    event += newDelegate((BaseUnlinkClass*)derivedClass, &BaseUnlinkClass::virFunc);

    // 添加类的静态成员函数
    event += newDelegate(&DerivedClass::staticFunc);

    // 添加模板函数
    event += newDelegate(TFunc);
   
    // 触发事件
    event(1, 2);
    cout << endl;

    // 去掉函数
    event -= newDelegate(func);

    // 去掉baseUnlinkClass所有的函数
    event.clear(baseUnlinkClass);

    // 去掉derivedClass所有的函数
    // 注意静态成员函数staticFunc不会去掉
    event.clear(derivedClass);

    //event.clear(normalClass);
    // 错误调用，normalClass不是IDelegateUnlink的派生类
    // 不能使用clear去掉自身的函数
    // 应该使用如下方法
    event -= newDelegate(normalClass, &NormalClass::normalFunc);
   
    // 触发事件
    event(2, 3);
    cout << endl;

    return 0;
}

 

摘自：gouki04的专栏