如何使用函数指针同时兼容普通函数与类成员函数？

我完全懂你想要的这种通用事件句柄需求——既要能挂靠类的成员函数，又得兼容普通函数指针，灵活处理不同场景的回调逻辑。你找到的这个方案虽然称不上最优，但确实是个能用的务实思路，先把你的Event.h核心代码片段贴出来方便大家理解：

#include <map>

class BasicEvent {
public:
    BasicEvent(int id) : eventId(id) {}
    int GetId() const { return eventId; }
    virtual void ObjectMethode() {}
protected:
    const int eventId;
    // ... 你代码中省略的其他实现细节
};

这个方案的核心思路 #

你应该是通过基类+多态的方式来统一接口：

• BasicEvent作为所有事件类型的基类，用虚函数ObjectMethode提供统一的调用入口
• 后续可以派生出两个子类：一个封装普通函数指针，另一个封装类成员函数指针（需要绑定对象实例）
• 最后用std::map<int, BasicEvent*>这类容器，按事件ID来存储和管理不同的事件句柄，触发时通过基类指针调用虚函数即可

为什么说它“非最优”？ #

这个方案的局限性也很明显：

1. 需要手动为不同函数类型编写子类，代码冗余度高
2. 虚函数调用有微小的性能开销（对大部分场景可以忽略，但极端性能敏感场景需要注意）
3. 手动管理BasicEvent子类对象的内存，容易出现内存泄漏

补充一个更简洁的替代思路（供参考） #

如果想少写点冗余代码，也可以用C++11引入的std::function+std::bind/lambda来实现，不需要手动派生子类：

#include <functional>
#include <map>

class EventManager {
public:
    // 注册任意可调用对象：普通函数、成员函数、lambda等
    template<typename Callable>
    void RegisterEvent(int eventId, Callable&& func) {
        m_events[eventId] = std::function<void()>(std::forward<Callable>(func));
    }

    // 触发指定ID的事件
    void TriggerEvent(int eventId) {
        auto iter = m_events.find(eventId);
        if (iter != m_events.end()) {
            iter->second();
        }
    }

private:
    std::map<int, std::function<void()>> m_events;
};

使用示例

// 普通函数
void NormalCallback() {
    // 普通函数逻辑
}

// 带成员函数的类
class MyClass {
public:
    void MemberCallback() {
        // 类成员函数逻辑
    }
};

int main() {
    EventManager manager;
    
    // 注册普通函数
    manager.RegisterEvent(1001, NormalCallback);
    
    // 注册类成员函数（用lambda捕获对象实例）
    MyClass obj;
    manager.RegisterEvent(1002, [&obj]() { obj.MemberCallback(); });
    
    // 触发事件
    manager.TriggerEvent(1001);
    manager.TriggerEvent(1002);
    
    return 0;
}

这个方案的优势是用std::function统一了所有可调用类型的接口，代码更简洁，也不需要手动管理子类对象的内存，唯一需要注意的是如果捕获对象实例的话，要确保对象生命周期长于事件触发的时机。

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