Como usar enumerações em C ++

Suponha que tenhamos enumo seguinte:

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

Eu quero criar uma instância disso enume inicializá-lo com um valor adequado, então eu faço:

Days day = Days.Saturday;

Agora eu quero verificar minha variável ou instância com um enumvalor existente , então eu faço:

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

O que me dá um erro de compilação:

erro: expressão primária esperada antes de '.' símbolo

Então, para ficar claro, qual é a diferença entre dizer:

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

e

if (day == Saturday)

?

A que esses dois realmente se referem, em que um está OK e um causa um erro de compilação?

Este código está errado:

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

Porque Daysnão é um escopo, nem um objeto. É um tipo. E os próprios tipos não têm membros. O que você escreveu é o equivalente a std::string.clear. std::stringé um tipo, então você não pode usá .-lo. Você usa .em uma instância de uma classe.

Infelizmente, as enums são mágicas e, portanto, a analogia pára por aí. Porque com uma classe, você pode fazer std::string::clearpara obter um ponteiro para a função de membro, mas no C ++ 03, Days::Sundayé inválido. (O que é triste). Isso ocorre porque o C ++ é (um pouco) retrocompatível com C e C não tinha namespaces, portanto, as enumerações precisavam estar no namespace global. Portanto, a sintaxe é simplesmente:

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

Felizmente, Mike Seymour observa que isso foi abordado no C ++ 11. Mude enumpara enum classe obtém seu próprio escopo; portanto, Days::Sundaynão é apenas válido, mas é a única maneira de acessar Sunday. Dias felizes!

Isso será suficiente para declarar sua variável enum e compará-la:

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

Muito disso deve fornecer erros de compilação.

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

Agora, Saturday, Sunday, etc. pode ser usado como de nível superior constantes descalços, e Dayspode ser usado como um tipo:

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

E da mesma forma mais tarde, para testar:

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

Esses enumvalores são como constantes nuas - sem escopo - com uma pequena ajuda extra do compilador: (a menos que você esteja usando classes enum C ++ 11 ), eles não são encapsulados como membros de objeto ou estrutura, por exemplo, e você não pode se referir a eles como membros de Days.

Você terá o que procura com o C ++ 11 , que apresenta enum class:

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

// ...

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

Observe que esse C ++ é um pouco diferente de C de duas maneiras: uma é que C requer o uso da enumpalavra - chave ao declarar uma variável:

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

Você pode usar um truque para usar escopos como desejar, basta declarar enum da seguinte maneira:

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

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

Em vez de usar um monte de instruções if, as enums se prestam bem para alternar instruções

Eu uso algumas combinações de enum / switch no construtor de níveis que estou construindo para o meu jogo.

EDIT: Outra coisa, eu vejo que você quer sintaxe semelhante a;

if(day == Days.Saturday)
etc

Você pode fazer isso em C ++:

if(day == Days::Saturday)
etc

Aqui está um exemplo muito simples:

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 você ainda estiver usando o C ++ 03 e quiser usar enumerações, use enumerações dentro de um espaço para nome. Por exemplo:

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

Você pode usar a enumeração fora do namespace, como

Daysofweek::Days day = Daysofweek::Saturday;

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

Você está procurando enumerações fortemente tipadas , um recurso disponível no padrão C ++ 11 . Transforma enumerações em classes com valores de escopo.

Usando seu próprio exemplo de código, é:

  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

O uso ::como acessador de enumerações falhará se tiver como alvo um padrão C ++ anterior ao C ++ 11. Mas alguns compiladores antigos não o suportam, e alguns IDEs simplesmente substituem essa opção e configuram um padrão C ++ antigo.

Se você estiver usando o GCC, ative o C + 11 com -std = c ++ 11 ou -std = gnu11 .

Seja feliz!

Isso não deve funcionar em C ++:

Days.Saturday

Dias não é um escopo ou objeto que contém membros que você pode acessar com o operador de ponto. Essa sintaxe é apenas um ismo de C # e não é legal em C ++.

A Microsoft mantém há muito tempo uma extensão C ++ que permite acessar os identificadores usando o operador de escopo:

enum E { A, B, C };

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

Mas isso não é padrão antes do C ++ 11. No C ++ 03, os identificadores declarados em uma enumeração existem apenas no mesmo escopo que o próprio tipo de enumeração.

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

O C ++ 11 torna legal qualificar identificadores de enum com o nome de enum e também introduz classes de enum, que criam um novo escopo para os identificadores em vez de colocá-los no escopo circundante.

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

enum class F { A, B, C };

A; // error
F::B;

Infelizmente, os elementos do enum são 'globais'. Você os acessa fazendo day = Saturday. Isso significa que você não pode ter enum A { a, b } ;e enum B { b, a } ;porque eles estão em conflito.

Enquanto o C ++ (excluindo o C ++ 11) possui enumerações, os valores neles são "vazados" no espaço para nome global.
Se você não deseja que eles vazem (e NÃO PRECISA usar o tipo de enum), considere o seguinte:

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

As enumerações em C ++ são como números inteiros mascarados pelos nomes que você atribui, quando você declara seus valores de enumeração (essa não é uma definição, apenas uma dica de como funciona).

Mas há dois erros no seu código:

1. Soletre enumtodas as minúsculas
2. Você não precisa do Days.sábado antes.
3. Se esse enum for declarado em uma classe, use if (day == YourClass::Saturday){}

Eu acho que o seu problema de raiz é o uso de em .vez de ::, que usará o espaço para nome.

Experimentar:

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 queremos o tipo estrito de segurança e o enum com escopo definido, o uso enum classé bom no C ++ 11.

Se tivéssemos que trabalhar no C ++ 98, podemos usar os conselhos de InitializeSahib, Sanpara habilitar a enumeração de escopo.

Se também queremos o tipo estrito de segurança, o código a seguir pode implementar algo parecido 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;
}

O código é modificado a partir do exemplo Mês da classe no livro C ++ Efetivo 3º: Item 18

Primeiro, faça 'E' em enum, 'e' como minúscula.

Segundo, solte o nome do tipo 'Days' em 'Days.Saturday'.

Terceiro ... compre um bom livro em C ++.