c++ - 如何在不向下转型的情况下调用派生类的成员函数

Question

我有一个 Message 类和 Processor 类的职位。每个处理器都可以即时接收一条或多条消息。由于每条消息都可以有一些不同的属性，我必须将该消息向下转换为具体的消息类，以实际处理它。
因为没有。消息类和进程类，我不想使用 dynamic_cast。
我尝试使用以下代码，但这会导致编译时错误。 此外，我可以灵活地将处理器指针附加到消息中(如果需要)，但反过来不行。

class Message  
{  
    public:  
    virtual const Message* const getMessage() const = 0;
};

class MA : public Message  
{  
    public:  
    const MA* const getMessage() const {return this;}
    void printMA() const{std::cout<<"I am MA"<<std::endl;}
};

class MB : public Message  
{  
    public:  
    const MB* const getMessage() const {return this;}
    void printMB() const{std::cout<<"I am MB"<<std::endl;}
};

class Processor  
{  
public:  
    virtual void process(const Message* m) = 0;

};

class PA : public Processor  
{  
    public:  
    void process(const Message* m) {processM(m->getMessage());}

    void processM(const MA*  m) {m->printMA();}
    void processM(const MB*  m) {m->printMB();}
};

int main()  
{  
    Message* m1 = new MA();  
    Message* m2 = new MB();  

    Processor* p1 = new PA();  
    p1->process(m1);
    p1->process(m2);
    return 0;
}

Answer 1

我最终使用“双重调度”来解决这个问题。现在，唯一的事情是我需要在 MessageProcessor 类中添加一个函数，每当我添加一个新的消息类型时，但我认为这很好。

class MessageProcessor
{
    public:
        virtual void process(const MA*) const{std::cout<<"unhandled:MA"<<std::endl;}
        virtual void process(const MB*) const{std::cout<<"unhandled:MB"<<std::endl;}
        virtual void process(const MC*) const{std::cout<<"unhandled:MC"<<std::endl;}
};

class Message
{
    public:
    virtual void process(const MessageProcessor*) const = 0;
};

class MA : public Message
{
    public:
    void printMA() const{std::cout<<"I am MA"<<std::endl;}
    virtual void process(const MessageProcessor* p) const {p->process(this);}
};

class MB : public Message
{
    public:
    void printMB() const{std::cout<<"I am MB"<<std::endl;}
    virtual void process(const MessageProcessor* p) const {p->process(this);}
};

class MC : public Message
{
    public:
    void printMC() const{std::cout<<"I am MC"<<std::endl;}
    virtual void process(const MessageProcessor* p) const {p->process(this);}
};

class Processor : public MessageProcessor
{
    public:
    void processM(const Message* m){m->process(this);}

};

class PA : public Processor
{
    public:
    void process(const MA*  m) const {m->printMA();}
    void process(const MB*  m) const {m->printMB();}
};

class PB : public Processor
{
    public:
    void process(const MA*  m) const {m->printMA();}
    void process(const MC*  m) const {m->printMC();}
};

int main()
{
    const Message* m1 = new MA();
    const Message* m2 = new MB();
    const Message* m3 = new MC();

    Processor* p1 = new PA();
    p1->processM(m1);
    p1->processM(m2);
    p1->processM(m3);

    Processor* p2 = new PB();
    p2->processM(m1);
    p2->processM(m2);
    p2->processM(m3);

    return 0;
}