Cómo usar enumeraciones en C ++

Supongamos que tenemos enumlo siguiente:

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

Quiero crear una instancia de esto enume inicializarlo con un valor adecuado, así que hago:

Days day = Days.Saturday;

Ahora quiero verificar mi variable o instancia con un enumvalor existente , así que hago:

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

Lo que me da un error de compilación:

error: expresión primaria esperada antes de '.' simbólico

Para que quede claro, ¿cuál es la diferencia entre decir:

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

y

if (day == Saturday)

?

¿A qué se refieren realmente estos dos, en que uno está bien y uno causa un error de compilación?

Este código está mal:

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

Porque Daysno es un alcance, ni un objeto. Es un tipo. Y los Tipos en sí mismos no tienen miembros. Lo que escribiste es el equivalente a std::string.clear. std::stringes un tipo, por lo que no puede usarlo .. Usas .en una instancia de una clase.

Desafortunadamente, las enumeraciones son mágicas, por lo que la analogía se detiene allí. Porque con una clase, puede hacer std::string::clearpara obtener un puntero a la función miembro, pero en C ++ 03, Days::Sundayno es válido. (Lo cual es triste) Esto se debe a que C ++ es (algo) retrocompatible con C, y C no tenía espacios de nombres, por lo que las enumeraciones tenían que estar en el espacio de nombres global. Entonces la sintaxis es simplemente:

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

Afortunadamente, Mike Seymour observa que esto se ha abordado en C ++ 11. Cambiar enuma enum classy que llega a su propio ámbito de aplicación; así Days::Sundayque no solo es válido, sino que es la única forma de acceder Sunday. ¡Días felices!

Esto será suficiente para declarar su variable enum y compararla:

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

Gran parte de esto debería darte errores de compilación.

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

Ahora, Saturday, Sunday, etc. puede ser utilizado como constantes desnudos de nivel superior, y Daysse puede utilizar como un tipo:

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

Y de manera similar más tarde, para probar:

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

Estos enumvalores son como constantes desnudas, sin ámbito, con un poco de ayuda adicional del compilador: (a menos que esté usando clases de enumeración de C ++ 11 ) no están encapsulados como miembros de objetos o estructuras, por ejemplo, y no puedes referirte a ellos como miembros de Days.

Tendrá lo que está buscando con C ++ 11 , que presenta un enum class:

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

// ...

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

Tenga en cuenta que este C ++ es un poco diferente de C en un par de formas, una es que C requiere el uso de la enumpalabra clave al declarar una variable:

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

Puede usar un truco para usar los ámbitos como desee, simplemente declare enum de la siguiente manera:

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

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

En lugar de usar un montón de declaraciones if, las enumeraciones se prestan bien para cambiar las declaraciones

Utilizo algunas combinaciones de enum / switch en el generador de niveles que estoy construyendo para mi juego.

EDITAR: Otra cosa, veo que quieres una sintaxis similar a;

if(day == Days.Saturday)
etc

Puedes hacer esto en C ++:

if(day == Days::Saturday)
etc

Aquí hay un ejemplo muy simple:

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

Si todavía usa C ++ 03 y desea usar enumeraciones, debería usar enumeraciones dentro de un espacio de nombres. P.ej:

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

Puede usar la enumeración fuera del espacio de nombres como,

Daysofweek::Days day = Daysofweek::Saturday;

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

Está buscando enumeraciones fuertemente tipadas , una característica disponible en el estándar C ++ 11 . Convierte las enumeraciones en clases con valores de alcance.

Usando su propio ejemplo de código, es:

  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

El uso ::como accesores a las enumeraciones fallará si se dirige a un estándar C ++ anterior a C ++ 11. Pero algunos compiladores antiguos no lo admiten, y algunos IDE simplemente anulan esta opción y configuran un viejo estándar de C ++.

Si está utilizando GCC, habilite C + 11 con -std = c ++ 11 o -std = gnu11 .

¡Sea feliz!

Esto no debería funcionar en C ++:

Days.Saturday

Days no es un ámbito u objeto que contenga miembros a los que pueda acceder con el operador de puntos. Esta sintaxis es solo un C # y no es legal en C ++.

Microsoft ha mantenido durante mucho tiempo una extensión C ++ que le permite acceder a los identificadores utilizando el operador de alcance:

enum E { A, B, C };

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

Pero esto no es estándar antes de C ++ 11. En C ++ 03, los identificadores declarados en una enumeración solo existen en el mismo ámbito que el tipo de enumeración en sí.

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

C ++ 11 hace legal calificar los identificadores enum con el nombre enum, y también introduce clases enum, que crean un nuevo alcance para los identificadores en lugar de colocarlos en el alcance circundante.

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

enum class F { A, B, C };

A; // error
F::B;

Lamentablemente, los elementos de la enumeración son 'globales'. Accede a ellos haciendo day = Saturday. Eso significa que no puede tener enum A { a, b } ;y enum B { b, a } ;porque están en conflicto.

Si bien C ++ (excluyendo C ++ 11) tiene enumeraciones, los valores en ellas se "filtraron" en el espacio de nombres global.
Si no desea que se filtren (y NO NECESITA usar el tipo de enumeración), considere lo siguiente:

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

Las enumeraciones en C ++ son como enteros enmascarados por los nombres que les da, cuando declara sus valores de enumeración (esto no es una definición, solo una pista de cómo funciona).

Pero hay dos errores en su código:

1. Deletrear enumtodo en minúsculas
2. No necesitas el Days.antes del sábado.
3. Si esta enumeración se declara en una clase, use if (day == YourClass::Saturday){}

Creo que su problema raíz es el uso de en .lugar de ::, que utilizará el espacio de nombres.

Tratar:

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

Si queremos la seguridad estricta del tipo y la enumeración de ámbito, el uso enum classes bueno en C ++ 11.

Si tuviéramos que trabajar en C ++ 98, podemos usar los consejos dados por InitializeSahib, Sanpara habilitar la enumeración de ámbito.

Si también queremos la seguridad estricta del tipo, el siguiente código puede implementar algo así 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;
}

El código se modifica a partir del ejemplo de la clase Mes en el libro Efectivo C ++ 3er: Artículo 18

En primer lugar, escriba 'E' en enumeración, 'e' como minúscula.

Segundo, suelte el nombre de tipo 'Días' en 'Días.Sábado'.

Tercero ... cómprate un buen libro de C ++.