para - struct c++

Cómo usar enumeraciones en C++

Question

Supongamos que tenemos una enum como la siguiente:

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

Quiero crear una instancia de esta enum e inicializarla con un valor adecuado, por lo que hago:

Days day = Days.Saturday;

Ahora quiero verificar mi variable o instancia con un valor enum existente, entonces lo 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

Entonces, para ser claros, ¿cuál es la diferencia entre decir:

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

y

if (day == Saturday)

?

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

Answer 1

Antes que nada, ponga ''E'' en enum, ''e'' como minúscula.

Segundo, coloque el nombre del tipo ''Días'' en ''Día. Sábado''.

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

Answer 2

Creo que tu problema raíz es el uso de . en lugar de :: , que usará 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";
}

Answer 3

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

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

Answer 4

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 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 de :: como acceso a las enumeraciones fallará si se dirige a un estándar de C ++ previo 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 !

Answer 5

Este código es incorrecto:

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

Porque los días no son un alcance, ni un objeto. Es un tipo. Y los tipos mismos no tienen miembros. Lo que escribiste es el equivalente a std::string.clear . std::string es un tipo, por lo que no puede usar . en eso. Tu usas en una instancia de una clase.

Desafortunadamente, las enumeraciones son mágicas y la analogía se detiene allí. Porque con una clase, puede hacer std::string::clear para obtener un puntero a la función de miembro, pero en C ++ 03, Days::Sunday no 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 simple:

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. Cambia la enum a la enum class y obtiene su propio alcance; entonces Days::Sunday no solo es válido, sino que es la única forma de acceder al Sunday . ¡Días felices!

Answer 6

Esto no debería funcionar en C ++:

Days.Saturday

Days no es un ámbito u objeto que contiene miembros a los que puede acceder con el operador de punto. Esta sintaxis es solo un C # -ism 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 existen solo en el mismo ámbito que el tipo de enumeración en sí.

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

C ++ 11 hace que sea 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 ubicarlos en el ámbito circundante.

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

enum class F { A, B, C };

A; // error
F::B;

Answer 7

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

Answer 8

Los mensajes en C ++ son como números enteros enmascarados por los nombres que les das, cuando declaras tus valores enum (esta no es una definición, solo una pista de cómo funciona).

Pero hay dos errores en tu código:

1. Hechizo enum todas las minúsculas
2. No necesitas los Days. antes del sábado.
3. Si esta enumeración se declara en una clase, utilice if (day == YourClass::Saturday){}

Answer 9

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

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

Answer 10

Mucho de esto debería darle errores de compilación.

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

Ahora, los Saturday , Sunday , etc. se pueden usar como constantes desnudas de nivel superior, y los Days se pueden usar como un tipo:

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

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

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

Estos valores de enum son como constantes desnudas, no están recogidos, con un poco de ayuda adicional del compilador: (a menos que esté usando clases enum de C ++ 11) no están encapsulados como miembros de objeto o estructura, por ejemplo, y no puedes referirte a ellos como miembros de Days .

Tendrás lo que estás buscando con C++11 , que introduce una 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 palabra clave enum al declarar una variable:

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

Answer 11

Puedes usar un truco para usar los ámbitos como desees, solo declara enum de la siguiente manera:

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

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

Answer 12

Si todavía está utilizando C ++ 03 y quiere utilizar enumeraciones, debería utilizar enumeraciones dentro de un espacio de nombres. P.ej:

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

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

Daysofweek::Days day = Daysofweek::Saturday;

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

Answer 13

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