Andere enum in der Methode "overriden" zurückgeben

Question

Angenommen, Sie müssen in C++ 03 ein System entwerfen, in dem Sie verschiedene Arten von Nachrichten aus verschiedenen Quellen verwalten müssen.

Allen Nachrichten gemeinsam ist eine Eigenschaft, die die ID ist, eine Zahl, die bedeutet der Daten in der Nachricht enthaltenen.

Also die ID bezieht sich auf die Quelle, und verschiedene Quellen können gemeinsame ID anderer Quellen haben. Das ist SourceA und SourceB kann eine Nachricht mit ID auf 1 senden, trotz der Bedeutung der Daten in der Nachricht ist völlig anders.

So eine Basisklasse eine Nachricht darstellt, könnte wie folgt erklärt werden:

enum SourceType { 
    SourceA, 
    SourceB, 
    // ... 
}; 

struct Message { 
    virtual int getID(); 
    virtual SourceType getSource(); 
    // ... 
}; 

Da ich magische Zahl um meinen Code zu vermeiden, möchte breite ich die int mit etwas mehr sinnvoll ersetzen möchte enum, aber da jede Quelle ihre eigene unterschiedliche Aufzählung hat ist nicht möglich.

Eine Lösung könnte die int auf die richtige enum mit den Informationen von getSource zurückgegeben werden, aber es scheint ein sehr makelloses Design.

könnte eine andere Lösung, die eine große Enum mit allen möglichen ID für alle Quellen zu definieren, eine Menge Wert Duplizierung mit (das ist kein Fehler), wie folgt aus:

enum MessageID { 
    SourceA_ID1, 
    SourceA_ID2, 
    SourceB_ID1, 
    SourceB_ID2, 
    // ... 
}; 

Und so ist die getID Nachricht konnte MessageID zurückgeben, aber das bedeutet, dass MessageID in der Größe explodieren und könnte ein wenig chaotisch sein, um zu erhalten und dokumentiert werden.

Answer 1

Gehen Sie mit Ihrem ersten Alternative:

Eine Lösung, die int auf die richtige Enumeration werden könnten Gießen der Informationen von getSource zurück verwenden, aber es scheint ein sehr fehlerlos Design.

Grundsätzlich ist enum gleich int. Es gibt eine einfache Möglichkeit, um Konstanten zu erstellen und magische Zahlen im Code zu vermeiden. So ist es möglich zu haben:

enum SourceType { 
    SourceA, 
    SourceB, 
    // ... 
}; 

struct Message { 
    virtual int getID(); 
    virtual SourceType getSource(); 
    // ... 
}; 

// Maybe in "sourceA.h" 
enum SourceA_Ids { 
    SourceA_ID1 = 1, 
    SourceA_ID2 = 12, 
    SourceA_ID3 = 20 
}; 

// Maybe in "sourceB.h" 
enum SourceB_Ids { 
    SourceB_ID1 = 1, 
    SourceB_ID2 = 2, 
    SourceB_ID3 = 3 
}; 

Und in Ihrem Code, machen die Zuweisungen und Vergleiche direkt ohne Notwendigkeit, etwas zu werfen, weil Enum int implizit:

// sourceA.h 
struct MessageFromSourceA: Message { 
    double data; 
    ... 
    MessageFromSourceA() { 
     source = SourceA; 
     data = 0; 
    } 
}; 

// sourceA.cpp 
void processMsgFromSourceA(Message &msg) { 
    if (msg.getID() == SourceA_ID1) { 
     // Send an answer 
     MessageFromSourceA msga; 
     msga.id = SourceA_ID2; 
     msga.data = 123.456; 
     send(msga); 
    } 
} 

Wie Sie sehen: keine magischen Zahlen, keine Kompilierungsfehler.