Namespaces für Aufzählungstypen - bewährte Verfahren

Question

Oft benötigt man mehrere Aufzählungstypen zusammen. Manchmal kommt es zu einem Namenskonflikt. Hierfür gibt es zwei Lösungen: die Verwendung eines Namensraums oder die Verwendung "größerer" Aufzählungselementnamen. Für die Namespace-Lösung gibt es zwei mögliche Implementierungen: eine Dummy-Klasse mit verschachteltem Enum oder ein vollwertiger Namespace.

Ich bin auf der Suche nach den Vor- und Nachteilen aller drei Ansätze.

例

// oft seen hand-crafted name clash solution
enum eColors { cRed, cColorBlue, cGreen, cYellow, cColorsEnd };
enum eFeelings { cAngry, cFeelingBlue, cHappy, cFeelingsEnd };
void setPenColor( const eColors c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cColorBlue: //...
        //...
    }
 }

// (ab)using a class as a namespace
class Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
class Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
 }

 // a real namespace?
 namespace Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
 namespace Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
 void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
  }

Answer 1

Original C++03 Antwort:

Le site profitieren de un namespace (über eine class ) ist, dass Sie Folgendes verwenden können using Deklarationen, wenn Sie wollen.

Le site problème mit der Verwendung eines namespace ist, dass Namespaces an anderer Stelle im Code erweitert werden können. In einem großen Projekt kann man nicht sicher sein, dass zwei verschiedene Enums nicht beide denken, sie hießen eFeelings

Für einfacher aussehenden Code verwende ich eine struct da Sie vermutlich wollen, dass der Inhalt öffentlich ist.

Wenn Sie eine dieser Praktiken anwenden, sind Sie der Zeit voraus und brauchen dies wahrscheinlich nicht weiter zu hinterfragen.

Neuere, C++11 Ratschläge:

Wenn Sie C++11 oder höher verwenden, enum class werden die Enum-Werte implizit in den Enum-Namen einbezogen.

Mit enum class verlieren Sie implizite Konvertierungen und Vergleiche mit Integer-Typen, aber in der Praxis kann Ihnen das helfen, zweideutigen oder fehlerhaften Code zu entdecken.

Answer 2

FYI In C++0x gibt es eine neue Syntax für Fälle wie das, was Sie erwähnt (siehe C++0x-Wiki-Seite )

enum class eColors { ... };
enum class eFeelings { ... };

Answer 3

Ich habe die vorangegangenen Antworten zu etwas Ähnlichem zusammengefasst: (EDIT: Dies ist nur für Pre-C++11 nützlich. Wenn Sie C++11 verwenden, verwenden Sie enum class )

Ich habe eine große Header-Datei, die alle meine Projekt-Enums enthält, weil diese Enums von den Worker-Klassen gemeinsam genutzt werden und es nicht sinnvoll ist, die Enums in die Worker-Klassen selbst zu integrieren.

Le site struct vermeidet die Öffentlichkeit: syntaktischer Zucker und die typedef können Sie Variablen dieser Enums in anderen Workerklassen deklarieren.

Ich glaube nicht, dass die Verwendung eines Namensraums etwas bringt. Vielleicht liegt das daran, dass ich ein C#-Programmierer bin, und da kann man haben den Namen des Aufzählungstyps zu verwenden, wenn auf die Werte verwiesen wird, also bin ich daran gewöhnt.

    struct KeySource {
        typedef enum { 
            None, 
            Efuse, 
            Bbram
        } Type;
    };

    struct Checksum {
        typedef enum {
            None =0,
            MD5 = 1,
            SHA1 = 2,
            SHA2 = 3
        } Type;
    };

    struct Encryption {
        typedef enum {
            Undetermined,
            None,
            AES
        } Type;
    };

    struct File {
        typedef enum {
            Unknown = 0,
            MCS,
            MEM,
            BIN,
            HEX
        } Type;
    };

...

class Worker {
    File::Type fileType;
    void DoIt() {
       switch(fileType) {
       case File::MCS: ... ;
       case File::MEM: ... ;
       case File::HEX: ... ;
    }
}

Answer 4

Ich würde auf jeden Fall vermeiden, eine Klasse dafür zu verwenden; verwenden Sie stattdessen einen Namespace. Die Frage läuft darauf hinaus, ob ein Namespace oder eindeutige IDs für die Enum-Werte verwendet werden sollen. Ich persönlich würde einen Namespace verwenden, damit meine ids kürzer und hoffentlich selbsterklärender sind. Dann könnte der Anwendungscode eine "using namespace"-Direktive verwenden und alles besser lesbar machen.

Aus Ihrem obigen Beispiel:

using namespace Colors;

void setPenColor( const e c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cBlue: //...
        //...
    }
}

Answer 5

Der Vorteil der Verwendung einer Klasse ist, dass Sie eine vollwertige Klasse darauf aufbauen können.

#include <cassert>

class Color
{
public:
    typedef enum
    {
        Red,
        Blue,
        Green,
        Yellow
    } enum_type;

private:
    enum_type _val;

public:
    Color(enum_type val = Blue)
        : _val(val)
    {
        assert(val <= Yellow);
    }

    operator enum_type() const
    {
        return _val;
    }
};

void SetPenColor(const Color c)
{
    switch (c)
    {
        case Color::Red:
            // ...
            break;
    }
}

Wie das obige Beispiel zeigt, können Sie eine Klasse verwenden:

1. verbieten (leider nicht zur Kompilierzeit), dass C++ einen Cast von einem ungültigen Wert erlaubt,
2. einen Standardwert (ungleich Null) für neu erstellte Enums festlegen,
3. weitere Methoden hinzufügen, z. B. für die Rückgabe einer String-Repräsentation einer Auswahl.

Beachten Sie nur, dass Sie Folgendes angeben müssen operator enum_type() damit C++ weiß, wie es Ihre Klasse in ein zugrunde liegendes Enum umwandeln kann. Andernfalls können Sie den Typ nicht an eine switch Erklärung.