Come usare enum in C ++

Supponiamo di avere un enumsimile:

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

Voglio creare un'istanza di questo enume inizializzarlo con un valore corretto, quindi faccio:

Days day = Days.Saturday;

Ora voglio controllare la mia variabile o istanza con un enumvalore esistente , quindi faccio:

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

Il che mi dà un errore di compilazione:

errore: espressione primaria prevista prima di "." gettone

Per essere chiari, qual è la differenza tra dire:

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

e

if (day == Saturday)

?

A cosa si riferiscono effettivamente questi due, in quanto uno è OK e uno causa un errore di compilazione?

Questo codice è sbagliato:

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

Perché Daysnon è un ambito, né un oggetto. È un tipo. E i tipi stessi non hanno membri. Quello che hai scritto è l'equivalente di std::string.clear. std::stringè un tipo, quindi non puoi usarlo .. Si utilizza .su un'istanza di una classe.

Sfortunatamente, gli enum sono magici e quindi l'analogia si ferma qui. Perché con una classe, puoi fare std::string::clearper ottenere un puntatore alla funzione membro, ma in C ++ 03 Days::Sundaynon è valido. (Che è triste). Questo perché C ++ è (in qualche modo) retrocompatibile con C e C non aveva spazi dei nomi, quindi le enumerazioni dovevano essere nello spazio dei nomi globale. Quindi la sintassi è semplicemente:

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

Fortunatamente, Mike Seymour osserva che questo è stato risolto in C ++ 11. Cambia enumin enum classe ottiene il suo scopo; quindi Days::Sundaynon è solo valido, ma è l' unico modo per accedere Sunday. Giorni felici!

Questo sarà sufficiente per dichiarare la tua variabile enum e confrontarla:

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

Gran parte di questo dovrebbe darti errori di compilazione.

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

Ora, Saturday, Sunday, ecc può essere utilizzato come costanti nude-alto livello, e Dayspuò essere utilizzato come un tipo:

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

Allo stesso modo, per testare:

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

Questi enumvalori sono come costanti nude - sono senza ambito - con un piccolo aiuto aggiuntivo dal compilatore: (a meno che tu non stia usando le classi enum C ++ 11 ) non sono incapsulati come membri di oggetti o strutture per esempio, e non puoi riferirti a loro come membri diDays .

Avrai quello che stai cercando con C ++ 11 , che introduce un enum class:

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

// ...

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

Si noti che questo C ++ è leggermente diverso da C in un paio di modi, uno è che C richiede l'uso della enumparola chiave quando si dichiara una variabile:

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

Puoi usare un trucco per usare gli ambiti come desideri, dichiarando enum in questo modo:

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

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

Piuttosto che usare un mucchio di istruzioni if, gli enum si prestano bene a cambiare istruzione

Uso alcune combinazioni enum / switch nel costruttore di livelli che sto costruendo per il mio gioco.

EDIT: Un'altra cosa, vedo che vuoi una sintassi simile a;

if(day == Days.Saturday)
etc

Puoi farlo in C ++:

if(day == Days::Saturday)
etc

Ecco un esempio molto semplice:

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

Se stai ancora usando C ++ 03 e vuoi usare enums, dovresti usare enums all'interno di uno spazio dei nomi. Per esempio:

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

Puoi usare l'enum fuori dallo spazio dei nomi come

Daysofweek::Days day = Daysofweek::Saturday;

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

Stai cercando enumerazioni fortemente tipizzate , una funzionalità disponibile in C ++ 11 standard . Trasforma le enumerazioni in classi con valori di ambito.

Usando il tuo esempio di codice, è:

  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

L'uso ::come accesso alle enumerazioni fallirà se si sceglie come target uno standard C ++ precedente C ++ 11. Ma alcuni vecchi compilatori non lo supportano, così come alcuni IDE hanno semplicemente la precedenza su questa opzione e impostato un vecchio standard C ++.

Se stai usando GCC, abilita C + 11 con -std = c ++ 11 o -std = gnu11 .

Siate felici!

Questo non dovrebbe funzionare in C ++:

Days.Saturday

Days non è un ambito o un oggetto che contiene membri a cui è possibile accedere con l'operatore punto. Questa sintassi è solo un c # -ismo e non è legale in C ++.

Microsoft ha a lungo mantenuto un'estensione C ++ che consente di accedere agli identificatori utilizzando l'operatore scope:

enum E { A, B, C };

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

Ma questo non è standard prima di C ++ 11. In C ++ 03 gli identificatori dichiarati in un enum esistono solo nello stesso ambito del tipo enum stesso.

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

C ++ 11 rende legale qualificare gli identificatori di enum con il nome di enum e introduce anche le classi di enum, che creano un nuovo ambito per gli identificatori invece di collocarli nell'ambito circostante.

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

enum class F { A, B, C };

A; // error
F::B;

Purtroppo, gli elementi dell'enum sono "globali". Li accedete facendo day = Saturday. Ciò significa che non puoi avere enum A { a, b } ;e enum B { b, a } ;perché sono in conflitto.

Mentre C ++ (escluso C ++ 11) ha enumerazioni, i valori in esse contenuti vengono "filtrati" nello spazio dei nomi globale.
Se non vuoi farli trapelare (e NON DEVI usare il tipo enum), considera quanto segue:

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

Gli enum in C ++ sono come numeri interi mascherati dai nomi che dai loro, quando dichiari i tuoi valori enum (questa non è una definizione solo un suggerimento su come funziona).

Ma ci sono due errori nel tuo codice:

1. Scrivi enumtutte le lettere minuscole
2. Non ti serve Days.prima di sabato.
3. Se questo enum è dichiarato in una classe, allora usa if (day == YourClass::Saturday){}

Penso che il tuo problema di root sia l'uso di .invece di ::, che utilizzerà lo spazio dei nomi.

Provare:

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

Se vogliamo la sicurezza di tipo rigoroso e enum con ambito, usare enum classè buono in C ++ 11.

Se dovessimo lavorare in C ++ 98, possiamo usare i consigli forniti da InitializeSahib, Sanper abilitare l'enum con ambito.

Se vogliamo anche la rigorosa sicurezza dei tipi, il seguente codice può implementare qualcosa del genere 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;
}

Il codice viene modificato dall'esempio della classe Month nel libro Effective C ++ 3rd: Item 18

Prima di tutto, inserisci "E" in enum, "e" come minuscolo.

In secondo luogo, rilascia il nome del tipo "Giorni" in "Giorni. Giorno".

Terzo ... comprati un buon libro in C ++.