Jak używać wyliczeń w C ++

Załóżmy, że mamy enumpodobne:

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

Chcę utworzyć instancję tego enumi zainicjować ją z odpowiednią wartością, więc:

Days day = Days.Saturday;

Teraz chcę sprawdzić moją zmienną lub instancję z istniejącą enumwartością, więc:

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

Co daje mi błąd kompilacji:

błąd: oczekiwane wyrażenie podstawowe przed „.” znak

Żeby było jasne, jaka jest różnica między powiedzeniem:

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

i

if (day == Saturday)

?

Co tak naprawdę odnoszą się do tych dwóch, że jest OK, a drugi powoduje błąd kompilacji?

Ten kod jest nieprawidłowy:

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

Ponieważ Daysnie jest zakresem ani przedmiotem. To jest typ. A same typy nie mają członków. To, co napisałeś, jest odpowiednikiem std::string.clear. std::stringjest typem, więc nie możesz go używać .. Używasz .na instancji klasy.

Niestety wyliczenia są magiczne, więc analogia się tam kończy. Ponieważ w przypadku klasy można std::string::clearuzyskać wskaźnik do funkcji składowej, ale w C ++ 03 Days::Sundayjest niepoprawny. (Co jest smutne). Wynika to z tego, że C ++ jest (nieco) wstecznie kompatybilny z C, a C nie ma przestrzeni nazw, więc wyliczenia musiały znajdować się w globalnej przestrzeni nazw. Więc składnia jest po prostu:

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

Na szczęście Mike Seymour zauważa, że ​​zostało to rozwiązane w C ++ 11. Zmień enumsię enum classi uzyska swój zakres; Days::Sundayjest więc nie tylko poprawny, ale jest jedynym sposobem na dostęp Sunday. Szczęśliwe dni!

To wystarczy, aby zadeklarować zmienną enum i porównać ją:

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

Znaczna część tego powinna dać błędy kompilacji.

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

Teraz Saturday, Sundayitp mogą być stosowane jako najwyższego poziomu gołymi stałych i Daysmoże być używany jako typ:

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

I podobnie później, aby przetestować:

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

Te enumwartości są jak gołymi stałych - Są un -scoped - przy odrobinie pomocy ze strony kompilatora: (chyba, że używasz C ++ 11 klas enum ) oni nie są zamknięte jak przedmiot lub członków struktury, na przykład, i Państwo nie może odnosić się do nich jako członków o Days.

Będziesz mieć to, czego szukasz z C ++ 11 , który wprowadza enum class:

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

// ...

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

Zauważ, że ten C ++ różni się nieco od C na kilka sposobów, jeden jest taki, że C wymaga użycia enumsłowa kluczowego podczas deklarowania zmiennej:

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

Możesz użyć sztuczki, aby używać zakresów według własnego uznania, po prostu zadeklaruj enum w następujący sposób:

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

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

Zamiast używać szeregu instrukcji if, wyliczenia nadają się dobrze do przełączania instrukcji

Używam niektórych kombinacji wyliczania / przełączania w konstruktorze poziomów, który buduję dla mojej gry.

EDYCJA: Kolejna rzecz, widzę, że chcesz składnię podobną do;

if(day == Days.Saturday)
etc

Możesz to zrobić w C ++:

if(day == Days::Saturday)
etc

Oto bardzo prosty przykład:

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

Jeśli nadal używasz C ++ 03 i chcesz używać wyliczeń, powinieneś używać wyliczeń wewnątrz przestrzeni nazw. Na przykład:

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

Możesz użyć wyliczenia poza przestrzenią nazw, np.

Daysofweek::Days day = Daysofweek::Saturday;

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

Szukasz silnie typowanych wyliczeń , funkcja dostępna w standardzie C ++ 11 . Zamienia wyliczenia w klasy o wartościach zasięgu.

Korzystając z własnego kodu przykład:

  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

Użycie ::jako akcesorium do wyliczeń zakończy się niepowodzeniem, jeśli będzie się celować w standard C ++ wcześniejszy niż C ++ 11. Ale niektóre stare kompilatory go nie obsługują, a niektóre IDE po prostu zastępują tę opcję i ustawiają stary standard C ++.

Jeśli używasz GCC, włącz C + 11 za pomocą -std = c ++ 11 lub -std = gnu11 .

Bądź szczęśliwy!

To nie powinno działać w C ++:

Days.Saturday

Dni nie jest zakresem ani obiektem zawierającym członków, do których można uzyskać dostęp za pomocą operatora kropki. Ta składnia jest tylko językiem C # i nie jest legalna w C ++.

Microsoft od dawna utrzymuje rozszerzenie C ++, które umożliwia dostęp do identyfikatorów za pomocą operatora zasięgu:

enum E { A, B, C };

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

Ale jest to niestandardowe przed C ++ 11. W C ++ 03 identyfikatory zadeklarowane w wyliczeniu istnieją tylko w tym samym zakresie, co sam typ wyliczenia.

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

C ++ 11 zezwala na kwalifikowanie identyfikatorów enum za pomocą nazwy enum, a także wprowadza klasy enum, które tworzą nowy zakres dla identyfikatorów zamiast umieszczać je w otaczającym zakresie.

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

enum class F { A, B, C };

A; // error
F::B;

Niestety elementy wyliczenia są „globalne”. Masz do nich dostęp, robiąc day = Saturday. Oznacza to, że nie możesz mieć enum A { a, b } ;i enum B { b, a } ;są w konflikcie.

Podczas gdy C ++ (z wyjątkiem C ++ 11) ma wyliczenia, ich wartości są „wyciekane” do globalnej przestrzeni nazw.
Jeśli nie chcesz, aby wyciekły (i NIE POTRZEBUJESZ użyć typu wyliczeniowego), rozważ następujące kwestie:

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

Wyliczenia w C ++ są jak liczby całkowite zamaskowane nazwami, które im podajesz, kiedy deklarujesz swoje wartości wyliczeniowe (nie jest to definicja, tylko wskazówka, jak to działa).

Ale w twoim kodzie są dwa błędy:

1. Przeliteruj enumwszystkie małe litery
2. Nie potrzebujesz Days.przed sobotą.
3. Jeśli to wyliczenie jest zadeklarowane w klasie, użyj if (day == YourClass::Saturday){}

Myślę, że twoim głównym problemem jest użycie .zamiast ::, który użyje przestrzeni nazw.

Próbować:

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

Jeśli chcemy ścisłego bezpieczeństwa typu i wyliczania zakresu, używanie enum classjest dobre w C ++ 11.

Gdybyśmy musieli pracować w C ++ 98, moglibyśmy skorzystać z porady udzielonej przez InitializeSahib, Sanaby włączyć wyliczanie zakresu.

Jeśli chcemy również ścisłego bezpieczeństwa typu, poniższy kod może zaimplementować coś takiego 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;
}

Kod został zmodyfikowany na podstawie przykładu klasy miesiąc w książce Effective C ++ 3rd: Item 18

Przede wszystkim wpisz „E” in enum, „e” jako małą literę.

Po drugie, w polu „Days.Saturday” wpisz nazwę „Days”.

Po trzecie ... kup sobie dobrą książkę C ++.