## 使用 C++17 的 std::variant 与 std::visit 实现类型安全的事件系统

背景与需求

在传统的面向对象程序设计中，事件系统往往依赖继承与虚函数表（vtable）来实现多态。虽然易于实现，但在类型安全、性能以及跨平台兼容性上存在一定缺陷。尤其是当事件类型多且结构复杂时，使用多态会导致大量的类型转换和运行时检查，降低代码可维护性。

C++17 引入了 std::variant（多态联合体）和 std::visit（访问器），它们为我们提供了一种静态类型安全的方式来处理多种事件。通过组合这两种特性，我们可以构建一个轻量级、类型安全且易于扩展的事件系统。

关键技术点

1. std::variant
   std::variant<T...> 是一个能够存储多种类型之一的容器。它类似于 union，但对类型安全有严格的编译期检查。访问当前存储的值可以使用 std::get<T>(var) 或 std::get_if<T>(&var)。

2. std::visit
   std::visit(visitor, variant) 允许我们对 variant 中当前存储的值执行访问操作。访问器（visitor）可以是 Lambda、函数对象或函数指针，支持多态调用而不需要显式的类型判断。

3. 事件类型的定义
   每个事件都定义为一个 POD 结构体，包含必要的数据字段。通过将所有事件类型放入 std::variant 的模板参数列表，实现事件的统一管理。

4. 事件分发器（Dispatcher）
   事件分发器负责将事件传递给相应的处理器。使用 std::visit 可以避免显式的 if 或 switch 语句，提升可读性与维护性。

示例代码

#include <iostream>
#include <variant>
#include <vector>
#include <functional>

// 定义事件结构体
struct MouseMove {
    int x, y;
};

struct MouseClick {
    int button;
};

struct KeyPress {
    char key;
};

struct WindowResize {
    int width, height;
};

// 事件类型统一用 variant 包装
using Event = std::variant<MouseMove, MouseClick, KeyPress, WindowResize>;

// 事件处理器基类（可选）
class EventHandler {
public:
    virtual void onMouseMove(const MouseMove&) {}
    virtual void onMouseClick(const MouseClick&) {}
    virtual void onKeyPress(const KeyPress&) {}
    virtual void onWindowResize(const WindowResize&) {}
};

// 具体实现
class GuiApp : public EventHandler {
public:
    void onMouseMove(const MouseMove& e) override {
        std::cout << "Mouse moved to (" << e.x << ", " << e.y << ")\n";
    }
    void onMouseClick(const MouseClick& e) override {
        std::cout << "Mouse button " << e.button << " clicked\n";
    }
    void onKeyPress(const KeyPress& e) override {
        std::cout << "Key '" << e.key << "' pressed\n";
    }
    void onWindowResize(const WindowResize& e) override {
        std::cout << "Window resized to " << e.width << "x" << e.height << "\n";
    }
};

// 事件分发器
class Dispatcher {
public:
    Dispatcher(EventHandler& handler) : handler_(handler) {}

    void dispatch(const Event& ev) {
        std::visit([&](auto&& event) {
            using T = std::decay_t<decltype(event)>;
            if constexpr (std::is_same_v<T, MouseMove>)
                handler_.onMouseMove(event);
            else if constexpr (std::is_same_v<T, MouseClick>)
                handler_.onMouseClick(event);
            else if constexpr (std::is_same_v<T, KeyPress>)
                handler_.onKeyPress(event);
            else if constexpr (std::is_same_v<T, WindowResize>)
                handler_.onWindowResize(event);
        }, ev);
    }

private:
    EventHandler& handler_;
};

int main() {
    GuiApp app;
    Dispatcher dispatcher(app);

    std::vector <Event> events = {
        MouseMove{100, 200},
        MouseClick{1},
        KeyPress{'A'},
        WindowResize{800, 600}
    };

    for (const auto& ev : events) {
        dispatcher.dispatch(ev);
    }

    return 0;
}

优点总结

进一步思考

• 事件队列：将事件封装在线程安全的队列中，支持多线程事件产生与处理。
• 事件过滤：在 Dispatcher 里加入过滤器（lambda）仅转发满足条件的事件。
• 异步处理：结合 std::async 或线程池，将耗时事件异步执行。

通过 std::variant 与 std::visit 的组合，我们可以轻松实现一个高效、类型安全且易维护的事件系统，为现代 C++ 开发提供强有力的工具。