C++类方法类型指代及DELAGATE封装实现方案咨询

实现封装后的委托类 #

我们可以通过模板类+宏的方式实现你需要的分步绑定逻辑，以下是具体代码：

#include <functional>

// 封装后的委托类：模板参数指定类类型、返回值、参数列表
template <typename T, typename Ret, typename... Args>
class WrappedDelegate {
public:
    // 第一步：初始化，绑定类实例指针
    void Init(T* instance) {
        m_instance = instance;
    }

    // 第二步：绑定具体的成员函数
    void Set(Ret (T::*func)(Args...)) {
        // 将实例指针与成员函数绑定为可调用对象
        m_func = [this, func](Args... args) -> Ret {
            return (m_instance->*func)(std::forward<Args>(args)...);
        };
    }

    // 重载调用运算符，直接执行委托
    Ret operator()(Args... args) const {
        return m_func(std::forward<Args>(args)...);
    }

private:
    T* m_instance = nullptr;
    std::function<Ret(Args...)> m_func;
};

// 简化声明的宏，对应你需要的WRAP_DELEGATE
#define WRAP_DELEGATE(T, Ret, ...) WrappedDelegate<T, Ret, __VA_ARGS__>

在类中的使用示例 #

完全对应你要求的两步操作：

class A {
public:
    // 提前声明委托的类型：类A、返回int、参数char
    WRAP_DELEGATE(A, int, char) MyDelegate;

    void setup_delegate() {
        // 1. 初始化：绑定当前实例this
        MyDelegate.Init(this);
        // 2. 设置具体的成员函数
        MyDelegate.Set(&A::foo);
    }

    int foo(char a) {
        return static_cast<int>(a) + 1;
    }
};

// 测试调用
int main() {
    A a;
    a.setup_delegate();
    int result = a.MyDelegate('a'); // 返回98（'a'的ASCII值+1）
    return 0;
}

兼容原有Delegate实现的版本 #

如果你想复用你之前基于那篇博客实现的Delegate类，可以修改封装逻辑：

// 假设你已有的Delegate类定义
template <typename Ret, typename... Args>
class Delegate {
    // 原Delegate的实现逻辑（包含绑定、调用等）
public:
    template <typename T>
    Delegate(Ret (T::*func)(Args...), T* instance) {
        // 原有的成员函数绑定逻辑
    }

    Ret operator()(Args... args) const {
        // 原有的调用逻辑
    }
};

#define DELEGATE(func, instance) Delegate<decltype((instance->*func)(std::declval<Args>()...)), Args...>(func, instance)

// 兼容原Delegate的封装类
template <typename T, typename Ret, typename... Args>
class WrappedDelegate {
public:
    void Init(T* instance) {
        m_instance = instance;
    }

    void Set(Ret (T::*func)(Args...)) {
        m_delegate = DELEGATE(func, m_instance);
    }

    Ret operator()(Args... args) const {
        return m_delegate(std::forward<Args>(args)...);
    }

private:
    T* m_instance = nullptr;
    Delegate<Ret, Args...> m_delegate;
};

核心逻辑说明 #

• 模板参数提前锁定了类类型、成员函数返回值、参数列表，对应你说的"方法类型"；
• Init方法仅保存类实例指针this，完成第一步绑定；
• Set方法接收成员函数指针，将实例与函数绑定为可调用对象，完成第二步设置；
• 重载operator()让委托可以像普通函数一样被调用。

内容的提问来源于stack exchange，提问作者Shanti Schul