C++中delegate(委托)的实现

最新推荐文章于 2025-06-10 16:06:29 发布

原创

最新推荐文章于 2025-06-10 16:06:29 发布 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #list #generator #functor #delete #object

本文介绍了C++中如何实现委托(delegate)，包括本地回调、成员回调和委托的使用。通过示例展示了如何添加、移除回调函数，以及如何使用委托调用不同类型的函数和成员方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

delegate.h
#ifndef WAN_DELEGATE_H
#define WAN_DELEGATE_H

/**
* @author Kevin Wan <wanjunfeng@gmail.com>
* @date   06/30/2005
* Copyright (C) Kevin Wan
*/
#include "threadingmodel.h"

namespace wan
{
namespace local
{
template <typename> class ICallback;
template <typename> class NativeCallback;
template <typename, typename> class MemberCallback;
} // namespace local

template <typename, typename LockType = void> class delegate;

#define DELEGATE_GENERATOR(TEMPLATE_LIST, TYPE_LIST, TYPE_PARAM_LIST, PARAM_LIST) /
namespace local /
{ /
template <typename ReturnType TEMPLATE_LIST> /
class ICallback<ReturnType(TYPE_LIST)> /
{ /
    typedef ICallback<ReturnType(TYPE_LIST)> SelfType; /
/
public: /
    virtual ~ICallback() {} /
/
    virtual ReturnType invoke(TYPE_LIST) const = 0; /
    virtual bool equals(const SelfType* pDelegate) const = 0; /
    virtual SelfType* clone() const = 0; /
}; /
/
template <typename ReturnType TEMPLATE_LIST> /
class NativeCallback<ReturnType(TYPE_LIST)> /
    : public ICallback<ReturnType(TYPE_LIST)> /
{ /
    typedef ICallback<ReturnType(TYPE_LIST)> SuperType; /
    typedef NativeCallback<ReturnType(TYPE_LIST)> SelfType; /
    typedef ReturnType (*FunctionPtr)(TYPE_LIST); /
/
public: /
    explicit NativeCallback(FunctionPtr ptr) /
        : m_handler(ptr) /
    { /
    } /
/
    NativeCallback(const SelfType& rhs) /
        : ICallback<ReturnType(TYPE_LIST)>(rhs) /
        , m_handler(rhs.m_handler) /
    { /
    } /
/
    ReturnType invoke(TYPE_PARAM_LIST) const /
    { /
        return (*m_handler)(PARAM_LIST); /
    } /
/
    bool equals(const SuperType* pDelegate) const /
    { /
        const SelfType* pRhs = dynamic_cast<const SelfType*>(pDelegate); /
        if (pRhs == 0) return false; /
        if (m_handler == pRhs->m_handler) return true; /
        return false; /
    } /
/
    SelfType* clone() const /
    { /
        return new SelfType(*this); /
    } /
/
private: /
    FunctionPtr m_handler; /
}; /
/
template <typename ObjectType, typename ReturnType TEMPLATE_LIST> /
class MemberCallback<ObjectType, ReturnType(TYPE_LIST)> /
    : public ICallback<ReturnType(TYPE_LIST)> /
{ /
    typedef ICallback<ReturnType(TYPE_LIST)> SuperType; /
    typedef MemberCallback<ObjectType, ReturnType(TYPE_LIST)> SelfType; /
    typedef ReturnType (ObjectType::*FunctionPtr)(TYPE_LIST); /
    typedef ReturnType (ObjectType::*ConstFunctionPtr)(TYPE_LIST) const; /
/
    enum { CONST_POINTER, NEED_DELETE, DONT_DELETE }; /
    struct ObjectManager /
    { /
        bool equals(const ObjectManager& rhs) /
        { /
            return object.pObject == rhs.object.pObject; /
        } /
/
        union { ObjectType* pObject; const ObjectType* pConstObject; } object; /
        int                 property; /
        int                 refCount; /
    }; /
/
public: /
    MemberCallback(ObjectType* t, FunctionPtr ptr, bool needDelete = false) /
        : m_isConstMemFunc(false) /
    { /
        m_pObjectManager = new ObjectManager(); /
        m_pObjectManager->object.pObject = t; /
        m_pObjectManager->property = needDelete ? NEED_DELETE : DONT_DELETE; /
        m_pObjectManager->refCount = 0; /
        m_handler.ptr = ptr; /
        incrementRefCount(); /
    } /
/
    MemberCallback(ObjectType* t, ConstFunctionPtr ptr, bool needDelete = false) /
        : m_isConstMemFunc(true) /
    { /
        m_pObjectManager = new ObjectManager(); /
        m_pObjectManager->object.pObject = t; /
        m_pObjectManager->property = needDelete ? NEED_DELETE : DONT_DELETE; /
        m_pObjectManager->refCount = 0; /
        m_handler.constPtr = ptr; /
        incrementRefCount(); /
    } /
/
    MemberCallback(const ObjectType* t, ConstFunctionPtr ptr) /
        : m_isConstMemFunc(true) /
    { /
        m_pObjectManager = new ObjectManager(); /
        m_pObjectManager->object.pConstObject = t; /
        m_pObjectManager->property = CONST_POINTER; /
        m_pObjectManager->refCount = 0; /
        m_handler.constPtr = ptr; /
        incrementRefCount(); /
    } /
/
    MemberCallback(const SelfType& rhs) /
        : ICallback<ReturnType(TYPE_LIST)>(rhs) /
        , m_pObjectManager(rhs.m_pObjectManager) /
        , m_handler(rhs.m_handler) /
        , m_isConstMemFunc(rhs.m_isConstMemFunc) /
    { /
        incrementRefCount(); /
    } /
/
    virtual ~MemberCallback() /
    { /
        decrementRefCount(); /
    } /
/
    ReturnType invoke(TYPE_PARAM_LIST) const /
    { /
        if (m_isConstMemFunc) /
        { /
            if (m_pObjectManager->property == CONST_POINTER) /
                return (m_pObjectManager->object.pConstObject->*(m_handler.constPtr))(PARAM_LIST); /
            return (m_pObjectManager->object.pObject->*(m_handler.constPtr))(PARAM_LIST); /
        } /
        return (m_pObjectManager->object.pObject->*(m_handler.ptr))(PARAM_LIST); /
    } /
/
    bool equals(const SuperType* pDelegate) const /
    { /
&nbs