C++ 这是多态性的适当用法吗？

考虑这个语法正确的（？）伪代码：

class Event {
public:
    virtual int getID() const = 0;
    virtual int getSize() = 0;
    virtual void* getData() = 0;
    virtual void setData() = 0;
    //(I cannot define data at this level 'cos I don't know what it is yet)
}

class SpecialEvent : class Event {
public:
    virtual int getPGNID() const = 0;
    int getSourceAddress() {return source_address;}
    int setSourceAddress(int source_address) {this->source_address = source_address;}
protected:
    int source_address;
}

template <typename T, typename E>
class EventWrapper : public E {
    T data;
public:
    static int EVENT_ID;
    //implements everything in Event...EVENT_ID is assigned at runtime by some registry
}

class AnEvent : public EventWrapper<int, Event> {
     //public methods specific to AnEvent...
}

class AnotherEvent : public EventWrapper<long, SpecialEvent> {
    int getPGNID() const {static int ID = 10; return ID;}
}

class TheProcessingClass {
    AnEvent event1;
    AnotherEvent event2;

    void process(Event& e);
    void process(SpecialEvent& e);

    void doSomething() {
        process(event1);  //should invoke process(Event&)
        process(event2);  //should invoke process(SpecialEvent&)
    }
}

类事件{
公众：
虚拟int getID（）常量=0；
虚拟int getSize（）=0；
虚空*getData（）=0；
虚拟void setData（）=0；
//（我无法定义此级别的数据，因为我还不知道它是什么）
}
班级特别活动：班级活动{
公众：
虚拟int getPGNID（）常量=0；
int getSourceAddress（）{返回源地址；}
int setSourceAddress（int source\u address）{this->source\u address=source\u address；}
受保护的：
int源地址；
}
模板
类EventWrapper:public E{
T数据；
公众：
静态int事件ID；
//实现事件中的所有内容…事件ID在运行时由某个注册表分配
}
类AnEvent:公共事件包装器{
//特定于事件的公共方法。。。
}
类AnotherEvent:公共事件包装器{
int getPGNID（）常量{static int ID=10；返回ID；}
}
类处理类{
事件1；
另一事件2；
无效流程（事件与e）；
真空处理（特殊设备和设备）；
无效剂量测定法（）{
进程（event1）；//应该调用进程（Event&）
进程（event2）；//应调用进程（SpecialEvent&）
}
}

本质上，我有一个包装类，它包装T类型的数据，并从某种类型的

E

继承（在本例中是

Event

或

specialvent

）

我最初打算创建两个包装类

EventWrapper

和

SpecialEventWrapper

，直到我发现这两个类中的代码完全相同（只要它是从某种类型的

事件扩展而来的）

首先，这听起来像是基于策略的设计。但是，
事件
没有任何特殊行为…它们只保存一些数据。。。我是否滥用了这种模式

其次，有没有更好的方法？我在这里过于简单化了，但任何见解都将受到赞赏

编辑
我更新了我的示例…简言之，处理类正在侦听事件，并且应该根据事件采取操作。我希望这有帮助……
我建议将process（）添加为类事件的成员函数

class Event {
    int getID() const;
    void process();
    //class stuff
}

class SpecialEvent : class Event {
    int getSpecialID() const;
    void process(); //special version of process()
    //class stuff
}


class TheProcessingClass {
    Event event1;
    SpecialEvent event2;

    void doSomething() {
        event1.process();
        event2.process();
    }
}

我已经使用了你的代码一段时间了。
在我看来，你正试图做一些非常像

如果不是，我的主要建议是对Event和SpecialEvent使用真正的抽象接口。由于SpecialEvent有一个方法，更重要的是一个IDENTITY方法，它不会覆盖Event:：getId，因此您的设计只是部分多态性。这种“感觉”非常糟糕，我相信，当你以后以任何通用方式依赖Id概念时，肯定会导致你陷入困境

在您的设计中，您需要在类（类型）标识和对象（实例）标识之间建立明确的区别。到目前为止，您似乎只使用对象（实例）标识，否则您的id（）方法将是静态的。
可用于建立类标识，但取决于实际派生类型，这是一种典型的反模式，通常表示已断开的多态性。我从来没有需要RTTI，即使是出于日志记录的目的。
回答您问题的关键代码是两个进程函数及其作用。将SpecialEvent或从SpecialEvent派生的EventWrapper传递给
进程（事件&）
函数是否不正确？如果是这样，那么这不是多态性的恰当用法。
@T Reddy:那又怎样？如果你不需要它是一个POD，那就让它成为一个成员函数。+1代表“语法正确的伪代码”=）我不认为将SpecialEvent传递给只处理事件的东西是不正确的…任何正在侦听事件的东西都可能不在乎它是SpecialEvent类型。。。