C++ - Polymorphismus - Fehler beim Ableiten abgeleiteter Elemente zur Methode

Question

Wie der Titel sagt, stehe ich während der Entwicklung meines Projekts mit Polymorphismusproblemen fest. Ich habe bereits online gesucht, aber keine Antwort befriedigt meine Zweifel.

So ist die Situation ist folgende:

1. definiert Basis abstrakte Klasse für Nachrichten, MessageBase eine abstrakte Klasse Nachricht definiert, eine Template-Klasse MessageBase definiert, die aus der Nachricht abgeleitet wird. Die verschiedenen Nachrichten werden dann von der MessageBase-Vorlagenklasse abgeleitet (ich werde die Header zur Verdeutlichung bereitstellen)
2. hat eine Methode geschrieben writeMessage (Message * message); Dies akzeptiert einen Zeiger auf die Basisklasse, von der MessageBase und dann DerivedMessage (s) erbt.

Die Klassen sind wie folgt definiert (Bericht nur Header-Dateien):

Message* element = new DerivedMessageX(); //where DerivedMessageX is one of the derived message types 

element->setValue(x); //this raise an error, setValue is not part of class Message 

interface->writeMessage(element); //here the compiler does not recognize that my "element" is of base type MessageBase and so it tells that it cannot find any prototype to call. 

Die genaue:

//Message.hh 
class Message{ 

public: 
     Message(); 

protected: 
     virtual void write() = 0; 
     virtual void read() = 0; 
     virtual void handle() = 0;  
} 

//MessageBase.hh 
template<typename MessageType> 
class Messagebase : public Message { 
protected: 
    Handler handler; 
public: 
//define the three methods of base class 
void write() { handler.write(static_cast<MessageType&>(*this);} 
} 

void read() { handler.read(static_cast<MessageType&>(*this);} 
} 

void handle() { handler.handle(static_cast<MessageType&>(*this);} 
} 

}; 

//class DerivedMessageX.hh 

class DerivedMessageX : public MessageBase<DerivedMessageX> { 
public: 
... 
void setValue(int x); 

//other methods of that type of message 
} 

class Interface{ 

... 
... 
public: 
    void writeMessage(Message* message){ 
     message->write(); 
    } 
} 

Wenn ich versuche, die Nachricht schreiben zu nennen, ich so etwas wie dies durchführen Fehler ist: Fehler: keine übereinstimmende Funktion für den Aufruf von 'writeMessage (DerivedMessageX * message)'

In meinem Verständnis von Polymorphie weiß ich, dass ich eine Basisklasse mit rein virtuellen Methoden beschreibe, die allen abgeleiteten Klassen gemeinsam ist, und die abgeleiteten Klassen implementieren sie zusammen mit anderen spezifischen Methoden der abgeleiteten Klasse.

Also schrieb ich die Methode, um einen Zeiger auf einen Basisklasse-Typ zu akzeptieren, der eine Methode auf dem Objekt aufruft, das auf Basisklassenebene implementiert ist. Ich habe dies getan, weil ich nur eine Basisklassenmethode aufrufen musste und weil ich N writeMessage-Methoden nicht neu schreiben wollte, dachte ich, dass das Übergeben des abgeleiteten Nachrichtentyps, der wie oben beschrieben erstellt wurde, den Trick machen könnte.

Kann jemand darauf hinweisen, wo ich falsch liege?

Danke Jungs!

EDIT

Wie gewünscht, wird die Writemessage Verfahren wie folgt definiert:

int writeMessage(MessageBase* message){ 
    message->write();   // the method write() is base class level 
} 

und der Fehler sagt: Fehler: keine Anpassungsfunktion zum Aufruf ‚Writemessage (DerivedMessageX * message) '

EDIT schrieb die Frage in einem vollständigeren Weg. Entschuldigung Jungs

Answer 1

Es gibt eine Menge Dinge können möglicherweise fehlen, wenn Sie nicht eine minimale Version Ihres Codes bereitstellen.Hier

ist ein Ausschnitt, das tut, was Sie brauchen und arbeitet:

#include <iostream> 

class MessageBase 
{ 
    public: 
    // CTOR 
    MessageBase(){}; 

    virtual void printType(){ 
     std::cout << "MessageBase" << std::endl; 
    }; 

}; 

class DerivedMessageX: public MessageBase 
{ 
    public: 
    // CTOR 
    DerivedMessageX():MessageBase(){}; 

    void printType(){ 
     std::cout << "DeviredMessageX" << std::endl; 
    }; 
}; 


class Interface 
{ 
    public: 
    Interface(){}; 

    void writeMessage(MessageBase *elem){ 
     elem->printType(); 
    }; 
}; 

int main() 
{ 
    Interface interface; 

    MessageBase *base = new MessageBase(); 
    MessageBase *derived = new DerivedMessageX(); 


    interface.writeMessage(base); 
    interface.writeMessage(derived); 

    return 1; 
}; 

Die Ausgabe sollte sein:

MessageBase

DerivedMessageX