C++事件系统：lambda作可变参数订阅者遇std::function模板未定义问题

std::function不支持C风格可变参数（...）作为函数签名，你写的std::function<void(...)>是非法的，这直接导致编译器触发“隐式实例化未定义模板”的错误。

要实现支持不同参数的事件回调，以下是两种实用的现代C++方案：

方案1：基于多态事件基类的回调 #

定义统一的Event基类，所有具体事件类型继承它，回调统一接收Event*参数，在回调内部转换为具体事件类型处理：

代码实现 #

首先定义事件结构：

#include <memory>
#include <queue>
#include <map>
#include <functional>
#include <stdexcept>

// 事件类型枚举（需自行定义）
enum class EventType {
    KEY_EVENT,
    MOUSE_CLICK_EVENT
};

// 事件基类
class Event {
public:
    virtual ~Event() = default;
    virtual EventType get_type() const = 0;
};

// 具体事件：键盘事件
class KeyEvent : public Event {
public:
    int key_code;
    bool is_pressed;
    EventType get_type() const override { return EventType::KEY_EVENT; }
};

// 具体事件：鼠标点击事件
class MouseClickEvent : public Event {
public:
    int x, y;
    EventType get_type() const override { return EventType::MOUSE_CLICK_EVENT; }
};

修改EventDispatcher：

class EventDispatcher {
public:
    static void subscribe(EventType event_type, std::function<void(Event*)> callback) {
        event_subscribers[event_type] = std::move(callback);
    }

    void queue_event(std::unique_ptr<Event> event) {
        event_queue.push(std::move(event));
    }

    void dispatch_queue() {
        while (!event_queue.empty()) {
            auto event = std::move(event_queue.front());
            event_queue.pop();
            auto it = event_subscribers.find(event->get_type());
            if (it != event_subscribers.end()) {
                it->second(event.get());
            }
        }
    }

private:
    std::queue<std::unique_ptr<Event>> event_queue;
    static inline std::map<EventType, std::function<void(Event*)>> event_subscribers;
};

使用示例：

// 订阅键盘事件
EventDispatcher::subscribe(EventType::KEY_EVENT, [](Event* e) {
    auto key_event = dynamic_cast<KeyEvent*>(e);
    if (!key_event) return;
    // 处理键盘事件逻辑，比如打印按键码
});

// 入队事件
auto key_event = std::make_unique<KeyEvent>();
key_event->key_code = 65; // 'A'键
key_event->is_pressed = true;
EventDispatcher dispatcher;
dispatcher.queue_event(std::move(key_event));

dispatcher.dispatch_queue();

方案2：模板化订阅+变体存储事件 #

利用std::variant存储所有可能的事件类型，通过模板订阅函数支持任意签名的回调，分发时匹配类型直接调用：

代码实现 #

#include <variant>
#include <queue>
#include <map>
#include <functional>

// 复用之前定义的EventType、KeyEvent、MouseClickEvent
using EventVariant = std::variant<KeyEvent, MouseClickEvent>;

class EventDispatcher {
public:
    // 模板订阅函数，支持任意事件类型的回调
    template<typename EventT>
    static void subscribe(std::function<void(const EventT&)> callback) {
        EventType type = EventT::get_type_static(); // 需给每个事件类添加静态方法返回EventType
        event_subscribers[type] = [callback](const EventVariant& var) {
            if (const auto* e = std::get_if<EventT>(&var)) {
                callback(*e);
            }
        };
    }

    void queue_event(EventVariant event) {
        event_queue.push(std::move(event));
    }

    void dispatch_queue() {
        while (!event_queue.empty()) {
            auto& event = event_queue.front();
            EventType type = std::visit([](const auto& e) { return e.get_type(); }, event);
            auto it = event_subscribers.find(type);
            if (it != event_subscribers.end()) {
                it->second(event);
            }
            event_queue.pop();
        }
    }

private:
    std::queue<EventVariant> event_queue;
    static inline std::map<EventType, std::function<void(const EventVariant&)>> event_subscribers;
};

// 给KeyEvent添加静态方法
inline EventType KeyEvent::get_type_static() { return EventType::KEY_EVENT; }
// 给MouseClickEvent添加静态方法
inline EventType MouseClickEvent::get_type_static() { return EventType::MOUSE_CLICK_EVENT; }

使用示例：

// 订阅鼠标点击事件
EventDispatcher::subscribe<MouseClickEvent>([](const MouseClickEvent& e) {
    // 直接处理鼠标点击事件，无需类型转换
});

// 入队事件
EventDispatcher dispatcher;
dispatcher.queue_event(MouseClickEvent{100, 200});
dispatcher.dispatch_queue();

• 绝对避免使用C风格可变参数（...），它不符合类型安全要求，且std::function从设计上就不支持这种签名。
• 多态方案兼容性强，适合传统面向对象设计；变体方案类型更安全，无需动态类型转换，性能更优。

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