静的キャストと動的キャストを避ける

Question

マルチキャストメッセージを受信し、クラスにデータを解析し、キューを介して別のスレッドに の基本クラスポインタを渡すシステムを更新しています。もう一方のスレッドは、クラスからデータ を読み取り、テーブルに格納します。

私たちが受け取るメッセージは2種類あります。ここでは、クラスのデザインです：

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; 
} 

ここで受け取るコードは次のとおりです。

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); 
} 

ここでは別のスレッドで実行されるプロセスのコードは次のとおりです。

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 
    } 
} 

私が知っていることをメッセージタイプのチェックがダウンキャスティングはお粗末ですが、 の通信の制約を受けて、私はよりよい解決策を考え出すことができませんでした。ダイナミックキャスト<（パフォーマンス上の理由から 私はしたくない）を使用しても同じ問題が発生します。まだそれを知る必要があります msgToProcessに変換するクラスのタイプ。

キャスト&キャストを取り除く方法についてのご意見はありますか？私はたくさんの経験を持っています C & C++ですが、OOデザインではそれほどではないので、私は何も知らない方法があるかもしれません。

これは、質問を説明するために非常にすっきりした例です。 何百万ものメッセージを毎秒受信できるので、実際には は50種類以上のメッセージタイプであり、パフォーマンスは非常に重要です。

Answer 1

私はクラスBaseMsgの中で例えばdoStuff()と呼ばれる純粋仮想関数を定義します。
各派生クラスは、そのメソッドを実装しています。あなたのprocessMessage内
は、あなたは、単にmsgToProcess->doStuff()

Answer 2

を呼び出して、私は多型の固有の特性を使用してメンバ関数を使用することを示唆している他の人と同意します。

しかし、メッセージクラスをきれいに保つ必要があることも理解しています。私はVisitorパターンを（つまり、多型に依存している）を使用すると、この場合は良いアイデアかもしれないと思う：

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); 
} 

クールなことは、機能の一つは、の任意ののために欠落している場合、これはコンパイルされませんということです派生クラス。

編集：固定スタッフはコメントで指摘

EDIT2：

外部コードベース：

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); } 
}; 

ローカルコードベース：

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; 
} 

2つのコードベースの外部コードベースで&最小限の変更で