Verwendung von Aufzählungen in C ++

Angenommen, wir haben enumFolgendes:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};

Ich möchte eine Instanz davon erstellen enumund sie mit einem geeigneten Wert initialisieren, also mache ich:

Days day = Days.Saturday;

Jetzt möchte ich meine Variable oder Instanz mit einem vorhandenen enumWert überprüfen , also mache ich:

if (day == Days.Saturday)
{
    std::cout << "Ok its Saturday";
}

Was mir einen Kompilierungsfehler gibt:

Fehler: erwarteter primärer Ausdruck vor '.' Zeichen

Um klar zu sein, was ist der Unterschied zwischen den Worten:

if (day == Days.Saturday) // Causes compilation error

und

if (day == Saturday)

?

Worauf beziehen sich diese beiden eigentlich, da einer in Ordnung ist und einer einen Kompilierungsfehler verursacht?

Dieser Code ist falsch:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Days.Saturday;
if (day == Days.Saturday)

Weil Dayses weder ein Bereich noch ein Objekt ist. Es ist ein Typ. Und Typen selbst haben keine Mitglieder. Was Sie geschrieben haben, entspricht std::string.clear. std::stringist ein Typ, den Sie nicht verwenden .können. Sie verwenden .für eine Instanz einer Klasse.

Leider sind Aufzählungen magisch und so hört die Analogie hier auf. Denn mit einer Klasse können Sie std::string::cleareinen Zeiger auf die Member-Funktion abrufen, der in C ++ 03 Days::Sundayjedoch ungültig ist. (Was traurig ist). Dies liegt daran, dass C ++ (etwas) abwärtskompatibel mit C ist und C keine Namespaces hatte, sodass Aufzählungen im globalen Namespace sein mussten. Die Syntax lautet also einfach:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Saturday;
if (day == Saturday)

Glücklicherweise stellt Mike Seymour fest , dass dies in C ++ 11 behoben wurde. Wechseln Sie enumzu enum classund es bekommt seinen eigenen Umfang; Dies Days::Sundayist nicht nur gültig, sondern auch die einzige Möglichkeit, darauf zuzugreifen Sunday. Glückliche Tage!

Dies reicht aus, um Ihre Enum-Variable zu deklarieren und zu vergleichen:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Saturday;
if (day == Saturday) {
    std::cout << "Ok its Saturday";
}

Vieles davon sollte zu Kompilierungsfehlern führen.

// note the lower case enum keyword
enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };

Nun Saturday, Sundayusw. können als Top-Level - bare Konstanten verwendet werden, und Dayskann als eine Art verwendet werden:

Days day = Saturday;   // Days.Saturday is an error

Und ähnlich später, um zu testen:

if (day == Saturday)
    // ...

Diese enumWerte sind wie nackte Konstanten - sie sind un -scoped - mit ein wenig mehr Hilfe vom Compiler: (es sei denn , Sie verwenden C ++ 11 Enum - Klassen ) sie sind nicht wie Objekt oder Strukturelemente beispielsweise eingekapselt, und Sie können sie nicht als Mitglieder von bezeichnen Days.

Sie müssen , was Sie für mit der Suche C ++ 11 , die eine Einführung enum class:

enum class Days
{
    SUNDAY,
    MONDAY,
    // ... etc.
}

// ...

if (day == Days::SUNDAY)
    // ...

Beachten Sie, dass sich C ++ in einigen Punkten ein wenig von C unterscheidet. Zum einen erfordert C die Verwendung des enumSchlüsselworts, wenn eine Variable deklariert wird:

// day declaration in C:
enum Days day = Saturday;

Sie können einen Trick verwenden, um Bereiche nach Ihren Wünschen zu verwenden. Deklarieren Sie einfach die Aufzählung folgendermaßen:

struct Days 
{
   enum type
   {
      Saturday,Sunday,Tuesday,Wednesday,Thursday,Friday
   };
};

Days::type day = Days::Saturday;
if (day == Days::Saturday)

Anstatt eine Reihe von if-Anweisungen zu verwenden, eignen sich Aufzählungen gut, um Anweisungen zu wechseln

Ich verwende einige Enum / Switch-Kombinationen in dem Level Builder, den ich für mein Spiel baue.

EDIT: Eine andere Sache, ich sehe, Sie wollen eine ähnliche Syntax;

if(day == Days.Saturday)
etc

Sie können dies in C ++ tun:

if(day == Days::Saturday)
etc

Hier ist ein sehr einfaches Beispiel:

EnumAppState.h

#ifndef ENUMAPPSTATE_H
#define ENUMAPPSTATE_H
enum eAppState
{
    STARTUP,
    EDIT,
    ZONECREATION,
    SHUTDOWN,
    NOCHANGE
};
#endif

Somefile.cpp

#include "EnumAppState.h"
eAppState state = eAppState::STARTUP;
switch(state)
{
case STARTUP:
    //Do stuff
    break;
case EDIT:
    //Do stuff
    break;
case ZONECREATION:
    //Do stuff
    break;
case SHUTDOWN:
    //Do stuff
    break;
case NOCHANGE:
    //Do stuff
    break;
}

Wenn Sie immer noch C ++ 03 verwenden und Aufzählungen verwenden möchten, sollten Sie Aufzählungen in einem Namespace verwenden. Z.B:

namespace Daysofweek{
enum Days {Saturday, Sunday, Tuesday,Wednesday, Thursday, Friday};
}

Sie können die Aufzählung außerhalb des Namespace wie folgt verwenden:

Daysofweek::Days day = Daysofweek::Saturday;

if (day == Daysofweek::Saturday)
{
    std::cout<<"Ok its Saturday";
}

Sie suchen nach stark typisierten Aufzählungen , eine Funktion, die im C ++ 11- Standard verfügbar ist . Aufzählungen werden in Klassen mit Bereichswerten umgewandelt.

Anhand Ihres eigenen Codebeispiels ist dies:

  enum class Days {Saturday, Sunday, Tuesday,Wednesday, Thursday, Friday};
  Days day = Days::Saturday;

  if (day == Days::Saturday)  {
    cout << " Today is Saturday !" << endl;
  }
  //int day2 = Days::Sunday; // Error! invalid

Die Verwendung ::als Accessoren für Aufzählungen schlägt fehl, wenn auf einen C ++ - Standard vor C ++ 11 abgezielt wird. Einige alte Compiler unterstützen dies jedoch nicht. Einige IDEs überschreiben diese Option einfach und legen einen alten C ++ - Standard fest.

Wenn Sie GCC verwenden, aktivieren Sie C + 11 mit -std = c ++ 11 oder -std = gnu11 .

Sei glücklich!

Dies sollte in C ++ nicht funktionieren:

Days.Saturday

Tage ist kein Bereich oder Objekt, das Mitglieder enthält, auf die Sie mit dem Punktoperator zugreifen können. Diese Syntax ist nur ein C # -Imismus und in C ++ nicht zulässig.

Microsoft hat seit langem eine C ++ - Erweiterung beibehalten, mit der Sie mithilfe des Bereichsoperators auf die Bezeichner zugreifen können:

enum E { A, B, C };

A;
E::B; // works with Microsoft's extension

Dies ist jedoch vor C ++ 11 kein Standard. In C ++ 03 existieren die in einer Aufzählung deklarierten Bezeichner nur im selben Bereich wie der Aufzählungstyp selbst.

A;
E::B; // error in C++03

In C ++ 11 ist es zulässig, Enum-Bezeichner mit dem Enum-Namen zu qualifizieren, und es werden Enum-Klassen eingeführt, die einen neuen Bereich für die Bezeichner erstellen, anstatt sie in den umgebenden Bereich zu setzen.

A;
E::B; // legal in C++11

enum class F { A, B, C };

A; // error
F::B;

Während C ++ (außer C ++ 11) Aufzählungen enthält, werden die darin enthaltenen Werte in den globalen Namespace "durchgesickert".
Wenn Sie nicht möchten, dass sie durchgesickert sind (und nicht den Aufzählungstyp verwenden MÜSSEN), beachten Sie Folgendes:

class EnumName {  
   public:   
      static int EnumVal1;  
      (more definitions)  
};  
EnumName::EnumVal1 = {value};  
if ([your value] == EnumName::EnumVal1)  ...

Leider sind Elemente der Aufzählung "global". Sie greifen auf sie zu, indem Sie dies tun day = Saturday. Das bedeutet, dass Sie nicht haben können enum A { a, b } ;und enum B { b, a } ;für sie in Konflikt stehen.

Aufzählungen in C ++ sind wie Ganzzahlen, die durch die Namen maskiert werden, die Sie ihnen geben, wenn Sie Ihre Aufzählungswerte deklarieren (dies ist keine Definition, sondern nur ein Hinweis darauf, wie es funktioniert).

Ihr Code enthält jedoch zwei Fehler:

1. Buchstabiere enumalle Kleinbuchstaben
2. Du brauchst das nicht Days.vor Samstag.
3. Wenn diese Aufzählung in einer Klasse deklariert ist, verwenden Sie if (day == YourClass::Saturday){}

Ich denke, Ihr Hauptproblem ist die Verwendung von .anstelle von ::, wodurch der Namespace verwendet wird.

Versuchen:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Days::Saturday;
if(Days::Saturday == day)  // I like literals before variables :)
{
    std::cout<<"Ok its Saturday";
}

Wenn wir die strenge Typensicherheit und die Enumeration mit Gültigkeitsbereich wünschen, ist die Verwendung enum classin C ++ 11 gut.

Wenn wir in C ++ 98 arbeiten mussten, können wir die Ratschläge von verwenden InitializeSahib, Sanum die Enumeration mit Gültigkeitsbereich zu aktivieren.

Wenn wir auch die strenge Typensicherheit wollen, kann der folgende Code so etwas implementieren enum.

#include <iostream>
class Color
{
public:
    static Color RED()
    {
        return Color(0);
    }
    static Color BLUE()
    {
        return Color(1);
    }
    bool operator==(const Color &rhs) const
    {
        return this->value == rhs.value;
    }
    bool operator!=(const Color &rhs) const
    {
        return !(*this == rhs);
    }

private:
    explicit Color(int value_) : value(value_) {}
    int value;
};

int main()
{
    Color color = Color::RED();
    if (color == Color::RED())
    {
        std::cout << "red" << std::endl;
    }
    return 0;
}

Der Code wurde gegenüber dem Beispiel für die Klasse Monat in Buch Effective C ++ 3: Punkt 18 geändert

Machen Sie zuerst 'E' in Aufzählung, 'e' als Kleinbuchstaben.

Zweitens geben Sie den Typnamen 'Days' in 'Days.Saturday' ein.

Drittens ... kaufen Sie sich ein gutes C ++ - Buch.