Comment utiliser les énumérations en C ++

Supposons que nous ayons un enumcomme ceci:

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

Je veux créer une instance de ceci enumet l'initialiser avec une valeur appropriée, alors je fais:

Days day = Days.Saturday;

Maintenant, je veux vérifier ma variable ou mon instance avec une enumvaleur existante , alors je fais:

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

Ce qui me donne une erreur de compilation:

erreur: expression primaire attendue avant '.' jeton

Donc, pour être clair, quelle est la différence entre dire:

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

et

if (day == Saturday)

?

À quoi ces deux se réfèrent-ils réellement, dans le sens où l'un est OK et l'autre provoque une erreur de compilation?

Ce code est faux:

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

Parce que ce Daysn'est pas une portée, ni un objet. C'est un type. Et les types eux-mêmes n'ont pas de membres. Ce que vous avez écrit est l'équivalent de std::string.clear. std::stringest un type, vous ne pouvez donc pas l'utiliser .. Vous utilisez .sur une instance d'une classe.

Malheureusement, les énumérations sont magiques et donc l'analogie s'arrête là. Parce qu'avec une classe, vous pouvez faire std::string::clearpour obtenir un pointeur sur la fonction membre, mais en C ++ 03, Days::Sundayn'est pas valide. (Ce qui est triste). C'est parce que C ++ est (quelque peu) rétrocompatible avec C, et C n'avait pas d'espaces de noms, donc les énumérations devaient être dans l'espace de noms global. La syntaxe est donc simplement:

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

Heureusement, Mike Seymour observe que cela a été résolu en C ++ 11. Changez enumpour enum classet il obtient sa propre portée; Days::Sundayn'est donc pas seulement valable, mais c'est le seul moyen d'y accéder Sunday. Jours heureux!

Ce sera suffisant pour déclarer votre variable enum et la comparer:

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

Une grande partie de cela devrait vous donner des erreurs de compilation.

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

Maintenant, Saturday, Sunday, etc. peuvent être utilisés comme des constantes nues de haut niveau, et Dayspeut être utilisé comme un type:

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

Et de même plus tard, pour tester:

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

Ces enumvaleurs sont comme des constantes nues - elles n'ont pas de portée - avec un peu d'aide supplémentaire du compilateur: (à moins que vous n'utilisiez des classes d'énumération C ++ 11 ), elles ne sont pas encapsulées comme des membres d'objet ou de structure par exemple, et vous ne pouvez pas vous y référer en tant que membres de Days.

Vous aurez ce que vous cherchez avec C ++ 11 , qui introduit un enum class:

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

// ...

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

Notez que ce C ++ est un peu différent de C de deux manières, l'une est que C nécessite l'utilisation du enummot - clé lors de la déclaration d'une variable:

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

Vous pouvez utiliser une astuce pour utiliser les étendues comme vous le souhaitez, déclarez simplement enum de la manière suivante:

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

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

Plutôt que d'utiliser un tas d'instructions if, les énumérations se prêtent bien aux instructions switch

J'utilise des combinaisons enum / switch dans le générateur de niveau que je construis pour mon jeu.

EDIT: Une autre chose, je vois que vous voulez une syntaxe similaire à;

if(day == Days.Saturday)
etc

Vous pouvez le faire en C ++:

if(day == Days::Saturday)
etc

Voici un exemple très 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 vous utilisez toujours C ++ 03 et souhaitez utiliser des énumérations, vous devez utiliser des énumérations dans un espace de noms. Par exemple:

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

Vous pouvez utiliser l'énumération en dehors de l'espace de noms comme,

Daysofweek::Days day = Daysofweek::Saturday;

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

Vous recherchez des énumérations fortement typées , une fonctionnalité disponible dans la norme C ++ 11 . Il transforme les énumérations en classes avec des valeurs de portée.

En utilisant votre propre exemple de code, c'est:

  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'utilisation en ::tant qu'accesseurs aux énumérations échouera si vous ciblez une norme C ++ antérieure à C ++ 11. Mais certains anciens compilateurs ne le prennent pas en charge, ainsi certains IDE remplacent simplement cette option et définissent un ancien std C ++.

Si vous utilisez GCC, activez C + 11 avec -std = c ++ 11 ou -std = gnu11 .

Soyez heureux!

Cela ne devrait pas fonctionner en C ++:

Days.Saturday

Jours n'est pas une étendue ou un objet contenant des membres auxquels vous pouvez accéder avec l'opérateur point. Cette syntaxe n'est qu'un cismisme et n'est pas légale en C ++.

Microsoft a longtemps maintenu une extension C ++ qui vous permet d'accéder aux identifiants à l'aide de l'opérateur d'étendue:

enum E { A, B, C };

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

Mais ce n'est pas standard avant C ++ 11. En C ++ 03, les identifiants déclarés dans une énumération n'existent que dans la même portée que le type énumération lui-même.

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

C ++ 11 rend légal la qualification des identificateurs d'énumération avec le nom d'énumération et introduit également des classes d'énumération, qui créent une nouvelle étendue pour les identificateurs au lieu de les placer dans l'étendue environnante.

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

enum class F { A, B, C };

A; // error
F::B;

Malheureusement, les éléments de l'énumération sont «mondiaux». Vous y accédez en faisant day = Saturday. Cela signifie que vous ne pouvez pas avoir enum A { a, b } ;et enum B { b, a } ;car ils sont en conflit.

Alors que C ++ (à l'exception de C ++ 11) a des énumérations, les valeurs qu'elles contiennent sont "divulguées" dans l'espace de noms global.
Si vous ne voulez pas les faire fuir (et que vous N'AVEZ PAS BESOIN d'utiliser le type enum), tenez compte des points suivants:

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

Les énumérations en C ++ sont comme des entiers masqués par les noms que vous leur donnez, lorsque vous déclarez vos valeurs d'énumération (ce n'est pas une définition seulement un indice sur la façon dont cela fonctionne).

Mais il y a deux erreurs dans votre code:

1. Épeler enum tous les minuscules
2. Vous n'avez pas besoin du Days. avant samedi.
3. Si cette énumération est déclarée dans une classe, utilisez if (day == YourClass::Saturday){}

Je pense que votre problème racine est l'utilisation de .au lieu de ::, qui utilisera l'espace de noms.

Essayer:

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 nous voulons la sécurité de type stricte et l'énumération de portée, l'utilisation enum classest bonne en C ++ 11.

Si nous devions travailler en C ++ 98, nous pouvons utiliser les conseils donnés par InitializeSahib, Sanpour activer l'énumération de portée.

Si nous voulons également la sécurité de type stricte, le code suivant peut implémenter quelque chose comme 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;
}

Le code est modifié à partir de l'exemple de classe Month dans le livre Effective C ++ 3rd: Item 18

Tout d'abord, faites «E» en énumération, «e» en minuscule.

Ensuite, déposez le nom du type «Days» dans «Days.Saturday».

Troisièmement ... achetez-vous un bon livre C ++.