C++中能否扩展枚举类EventId以实现事件类型动态扩展？

在某项目中，我需要一个由Subject持有、用于处理各类行为的Observer类。观察者通过调用onNotify(Event*)方法，根据事件类型执行对应逻辑，当前实现如下：

void SpecificObserver::onNotify( const Event* nevent )
{
    switch (nevent->GetId())
    {
    case EventId::Eventtype1:
        {
            const Eventtype1* type1 = dynamic_cast<const Eventtype1*>(nevent);
                        //some behaviour...
        }
        break;
    case EventId::Eventtype2:
        {
            const Eventtype2* type2 = dynamic_cast<const Eventtype2*>(nevent);
            //some other behaviour...
        }
        break;
    }
}

当前Event类与EventId枚举的定义如下：

enum class EventId{ Event, Eventtype1, Eventtype2 };

class Event
{
public:
    virtual EventId GetId() const { return EventId::Event; }
};

问题在于，新增事件类型时必须修改EventId枚举及Event类的代码。我希望仅定义空枚举类enum class EventId{ };，并在定义事件子类（如Event1）的位置扩展枚举元素，示例如下：

enum class EventId { //add element Eventtype1 };

class Event1 : public Event
{
public:
    Event1( Info* i )
        :
        i(i)
    {}
    EventId GetId() const override
    { return EventId::Eventtype1; }
public:
    Info* i;
};

以此实现无需修改原有Event类即可扩展事件类型，且各事件或观察者无需知晓与自身无关的事件类型。请问该方案是否可行？

你的方案不可行，核心原因在于C++的枚举类（enum class）不支持这种分散式扩展：

1. 重复定义枚举类会触发编译错误
   C++中，enum class EventId只能被定义一次。如果在事件子类的头文件中再次写enum class EventId { Eventtype1 };，会被编译器视为重复定义，直接报错。枚举类的所有成员必须在同一个定义中声明，无法拆分到多个文件或位置补充。

2. 类型匹配与运行期风险
   即便你想通过某种hack手段（比如用全局命名空间的普通枚举、或者强制类型转换）绕开重复定义问题，也会导致EventId的枚举值冲突风险——不同事件子类可能不小心定义相同的枚举值，而编译器无法检测这种冲突，最终会导致观察者的switch逻辑执行错误的分支。

3. 违背开闭原则的本质问题
   你当前的switch + dynamic_cast写法本身就存在扩展性问题：新增事件时不仅要改枚举，还要修改观察者的onNotify方法。你的方案试图解决枚举的修改问题，但没解决观察者代码的侵入性。

更合理的替代方案：利用多态反转控制逻辑 #

把事件处理逻辑从观察者转移到事件本身，让每个事件子类自己实现处理逻辑，或者让观察者针对特定事件类型注册回调，避免switch和类型转换：

方案1：事件类自带处理逻辑（访问者模式变种）

定义一个纯虚的Accept方法在基类Event中，让每个事件子类实现该方法并接受观察者访问：

class SpecificObserver; // 前向声明

class Event
{
public:
    virtual void Accept(SpecificObserver* observer) const = 0;
    virtual ~Event() = default;
};

class Eventtype1 : public Event
{
public:
    void Accept(SpecificObserver* observer) const override;
    // 事件专属数据
};

class SpecificObserver
{
public:
    void onNotify(const Event* nevent)
    {
        nevent->Accept(this);
    }

    void HandleEventtype1(const Eventtype1* event)
    {
        // 处理Eventtype1的逻辑
    }
};

// 在Eventtype1的实现文件中
void Eventtype1::Accept(SpecificObserver* observer) const
{
    observer->HandleEventtype1(this);
}

这种方式下，新增事件时只需要定义新的Event子类，并实现Accept方法，无需修改原有Event基类和观察者的核心逻辑（仅需给观察者新增对应处理方法，或者拆分多个观察者类对应不同事件）。

方案2：基于回调的事件订阅

让Subject维护事件类型到回调函数的映射，观察者可以针对特定事件类型注册回调，避免集中式的switch：

#include <unordered_map>
#include <functional>

using EventCallback = std::function<void(const Event*)>;

class Subject
{
private:
    std::unordered_map<int, std::vector<EventCallback>> eventCallbacks;
public:
    // 用事件类型的type_index作为键，避免枚举依赖
    template<typename TEvent>
    void Subscribe(EventCallback callback)
    {
        int typeKey = typeid(TEvent).hash_code();
        eventCallbacks[typeKey].push_back(std::move(callback));
    }

    void Notify(const Event* event)
    {
        int typeKey = typeid(*event).hash_code();
        auto it = eventCallbacks.find(typeKey);
        if (it != eventCallbacks.end())
        {
            for (auto& cb : it->second)
            {
                cb(event);
            }
        }
    }
};

// 观察者使用示例
SpecificObserver observer;
Subject subject;
subject.Subscribe<Eventtype1>([&](const Event* e) {
    const Eventtype1* event = static_cast<const Eventtype1*>(e);
    // 处理逻辑
});

这种方案完全摆脱了EventId枚举的依赖，新增事件时只需定义事件类，观察者按需订阅即可，无需修改任何原有核心代码。

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