Vermeiden Sie statische und dynamische Umwandlung

Question

Ich aktualisiere ein System, das Multicast-Nachrichten empfängt, analysiert die Daten in Klassen und übergibt dann einen Basisklassenzeiger an einen separaten Thread über eine Warteschlange. Der andere Thread liest dann die Daten aus den Klassen und speichert sie in Tabellen.

Es gibt 2 verschiedene Arten von Nachrichten, die wir erhalten. Hier ist die Klasse Design:

class BaseMsg 
{ 
public: 
    BaseMsg(char tp) : msgType(tp) {} 
    virtual ~BaseMsg() = 0; 

    char msgType; 
} 

class MsgType1 : public BaseMsg 
{ 
public: 
    MsgType1(int a, int b) : BaseMsg('1'), val1(a), val2(b) {} 
    virtual ~MsgType1(); 

    int val1, val2; 
} 

class MsgType2 : public BaseMsg 
{ 
public: 
    MsgType2(double a, double b) : BaseMsg('2'), val1(a), val2(b) {} 
    virtual ~MsgType2(); 

    double val1, val2; 
} 

Hier ist der Empfangscode:

void reciveMessage(char *datablob, MsgQueue *queue) 
{ 
    BaseMsg *msgReceived; 
    char type = datablob[0]; // message type is the first character in the data, 
           // the rest of the blob varies based on that type 
    if (type == '1') { 
     // code for parsing type 1 into 2 ints, i1, i2 
     msgReceived = new MsgType1(i1, i2); 
    } else { 
     // code for parsing type 2 into 2 doubles, d1, d2 
     msgReceived = new MsgType2(d1, d2); 
    } 
    queue->push(msgReceived); 
} 

Hier ist der Prozess-Code, der in einem separaten Thread ausgeführt wird:

void processMessage(MsgQueue *queue) 
{ 
    BaseMsg *msgToProcess = queue->pop(); 

    if (msgToProcess->msgType == '1') { 
     MsgType1 *mt1 = static_cast<MsgType1 *>(msgToProcess); 
     // do stuff with the message type 1 data 
    } else { 
     MsgType2 *mt2 = static_cast<MsgType2 *>(msgToProcess); 
     // do stuff with the message type 2 data 
    } 
} 

Ich weiß, dass die Prüfung für den Nachrichtentyp dann downcasting ist schlampig, aber angesichts der Beschränkungen der Kommunikation durch die Warteschlange, konnte ich nicht mit einer besseren Lösung kommen. Selbst mit dynamic_cast <> (die ich aus Leistungsgründen nicht tun möchte) würde das gleiche Problem führen; es muss immer noch wissen, welche Art von Klasse zu konvertieren msgToProcess.

Irgendwelche Vorschläge darüber, wie ich die Überprüfungen loswerden könnte & Casting? Ich habe viel Erfahrung mit C & C++, aber nicht viel mit OO-Design, so kann es einen Weg, über den ich nichts weiß.

Beachten Sie auch, dass dies ein extrem reduziertes Beispiel zur Veranschaulichung der Frage ist. Es sind tatsächlich über 50 verschiedene Nachrichtentypen, und die Leistung ist kritisch, da wir Millionen von Nachrichten pro Sekunde erhalten können.

Answer 1

Ich würde eine rein virtuelle Funktion namens doStuff() innerhalb der Klasse BaseMsg definieren.
Jede abgeleitete Klasse implementiert diese Methode.
Innerhalb Ihres processMessage, rufen Sie einfach msgToProcess->doStuff()

Answer 2

ich mit anderen zustimmen, der die inhärenten Eigenschaften von Polymorphismus verwenden vorgeschlagen haben und Member-Funktionen verwenden.

Aber ich verstehe auch die Notwendigkeit, die Nachrichtenklassen ziemlich sauber zu halten. Ich denke, ein Besucher-Muster verwenden (das beruht auf Polymorphismus) eine gute Idee, in diesem Fall sein kann:

class BaseMsg { 
public: 
    virtual void accept(MsgProcessor& p) = 0; 
}; 

class Msg1 : BaseMsg { 
public: 
    void accept(MsgProcessor& p) { p.process(*this); } 
}; 

class Msg2 : BaseMsg { 
public: 
    void accept(MsgProcessor& p) { p.process(*this); } 
}; 

class MsgProcessor { 
public: 
    void process(Msg1& m); 
    void process(Msg2& m); 
} 

Die kühle Sache ist, dass dies nicht kompilieren, wenn eine der Funktionen für jede der fehlenden abgeleitete Klassen.

bearbeiten: Fest Sachen wiesen darauf hin, in den Kommentaren

edit2: mit zwei Codebases & minimale Änderungen in der externen Code-Basis:

Externe Code-Basis:

class MsgVisitor; 
class BaseMsg { 
public: 
    virtual void accept(MsgVisitor&) = 0; 
}; 

class Msg1; 
class Msg2; 
class MsgVisitor { 
public: 
    virtual void visit(Msg1&) = 0; 
    virtual void visit(Msg2&) = 0; 
}; 

class Msg1 : public BaseMsg { 
public: 
    void accept(MsgVisitor& v) { v.visit(*this); } 
}; 

class Msg2 : public BaseMsg { 
public: 
    void accept(MsgVisitor& v) { v.visit(*this); } 
}; 

Local Code-Basis:

class MsgProcessor : public MsgVisitor { 
public: 
    void visit(Msg1& m) { ... } // do stuff for Msg1 
    void visit(Msg2& m) { ... } 
}; 

void processMessage(MsgQueue *queue) 
{ 
    BaseMsg *msgToProcess = queue->pop(); 
    msgToProcess->accept(MsgProcessor()); 
    //delete msgToProcess; 
}