Я хотел бы использовать шаблон асинхронного события, чтобы отделить мою программу. Я также хотел бы, чтобы базовый класс событий не обращал внимания на реализации, чтобы иметь самую широкую свободу передавать все, что мне нравится, по событию. Поэтому использование static_cast внутри переключателя кажется мне простым и, возможно, безопасным решением:

enum class EventType
{
    None,
    EventA,
    EventB
};

class BaseEvent
{
    public:
        BaseEvent(EventType t = EventType::None) : type(t) { }
        virtual ~BaseEvent() {}
        auto get_type() { return type; }
    private:
        EventType type;

    // Oblivious and clean interface
};

class EventA : public BaseEvent
{
    public:
        EventA() : BaseEvent(EventType::EventA) { }

    // ... whatever I like
};
class EventB : public BaseEvent
{
    public:
        EventB() : BaseEvent(EventType::EventB) { }

    // ... whatever I like
};

void handle_event(BaseEvent* pe)
{
    switch (pe->get_type())
    {
        case EventType::EventA:
        {
            EventA* original_a = static_cast<EventA*>(pe);

            // In this case I know what is "pe" and what 
            // operations and data I can access and use.

            break;
        }
        case EventType::EventB:
        {
            EventB* original_b = static_cast<EventB*>(pe);

            //...

            break;
        }
    }
}

Но я также знаю, что использование static_cast представляет определенный риск, поскольку нарушает проверку типов. С моей идеалистической точки зрения, в данном случае это не кажется таким уж опасным, даже с точки зрения ремонтопригодности в будущем. Нужно только проверить, что строка

case EventType::EventA:

согласуется со следующей строкой

EventA* original_a = static_cast<EventA*>(pe);

Я знаю, что теоретически это может показаться не такой уж проблемой, но на практике все обстоит иначе. Подойдет ли это решение для большого проекта? Есть ли лучшие стратегии для достижения этой закономерности?

Я знаю, что мог бы использовать массив или вектор std :: variant в базовом классе, но это кажется довольно ограничивающим в отношении возможных реализаций производных событий. Я также мог бы использовать карту для хранения имен параметров и их значений, но это кажется довольно медленным и недружелюбным к памяти, а также ограничивает возможные типы параметров.

В качестве альтернативы я мог бы также использовать dynamic_cast, хотя у него есть накладные расходы, но, возможно, он окупает затраты, увеличивая ремонтопригодность.

РЕДАКТИРОВАТЬ

Чтобы быть кратким, я забыл упомянуть некоторые важные детали вопроса:

• События должны быть полиморфно поставлены в очередь в контейнере, поэтому я думаю, что CRTP это невозможно.

• Контекст - это имитация на основе агентов в реальном времени (видеоигра), где у меня есть основной цикл, повторяющий события. События могут запускаться в любом месте на каждой итерации. Они будут обрабатываться определенными обработчиками в следующей итерации (ах).

  std::queue<BaseEvent*> past_events;
  
  int main()
  {
      while (true)
      {
          while (!past_events.empty())
          {
              handle_event(past_events.front());
  
              //handle_event2(...)
              //handle_event3(...)
              //...
  
              past_events.pop();
          }
  
          // New events are fired...
      }
  }