Comment puis-je répéter sur une énumération?

Je viens de remarquer que vous ne pouvez pas utiliser d'opérateurs mathématiques standard sur une énumération telle que ++ ou + =

Alors, quelle est la meilleure façon d'itérer à travers toutes les valeurs dans une énumération C ++?

La manière typique est la suivante:

enum Foo {
  One,
  Two,
  Three,
  Last
};

for ( int fooInt = One; fooInt != Last; fooInt++ )
{
   Foo foo = static_cast<Foo>(fooInt);
   // ...
}

Veuillez noter que l'énumération Lastest destinée à être ignorée par l'itération. En utilisant cette "fausse" Lasténumération, vous n'avez pas à mettre à jour votre condition de terminaison dans la boucle for à la dernière "vraie" énumération chaque fois que vous souhaitez ajouter une nouvelle énumération. Si vous souhaitez ajouter d'autres énumérations plus tard, ajoutez-les simplement avant Last. La boucle dans cet exemple fonctionnera toujours.

Bien sûr, cela tombe en panne si les valeurs d'énumération sont spécifiées:

enum Foo {
  One = 1,
  Two = 9,
  Three = 4,
  Last
};

Cela illustre le fait qu'une énumération n'est pas vraiment destinée à parcourir. La manière typique de traiter une énumération consiste à l'utiliser dans une instruction switch.

switch ( foo )
{
    case One:
        // ..
        break;
    case Two:  // intentional fall-through
    case Three:
        // ..
        break;
    case Four:
        // ..
        break;
     default:
        assert( ! "Invalid Foo enum value" );
        break;
}

Si vous voulez vraiment énumérer, remplissez les valeurs d'énumération dans un vecteur et parcourez-le. Cela traitera également correctement les valeurs d'énumération spécifiées.

#include <iostream>
#include <algorithm>

namespace MyEnum
{
  enum Type
  {
    a = 100,
    b = 220,
    c = -1
  };

  static const Type All[] = { a, b, c };
}

void fun( const MyEnum::Type e )
{
  std::cout << e << std::endl;
}

int main()
{
  // all
  for ( const auto e : MyEnum::All )
    fun( e );

  // some
  for ( const auto e : { MyEnum::a, MyEnum::b } )
    fun( e );

  // all
  std::for_each( std::begin( MyEnum::All ), std::end( MyEnum::All ), fun );

  return 0;
}

Si votre énumération commence par 0 et l'incrément est toujours 1.

enum enumType 
{ 
    A = 0,
    B,
    C,
    enumTypeEnd
};

for(int i=0; i<enumTypeEnd; i++)
{
   enumType eCurrent = (enumType) i;            
}

Sinon, je suppose que le seul pourquoi est de créer quelque chose comme un

vector<enumType> vEnums;

ajouter les éléments et utiliser des itérateurs normaux ....

Avec c ++ 11, il existe en fait une alternative: écrire un simple itérateur personnalisé basé sur des modèles.

supposons que votre énumération soit

enum class foo {
  one,
  two,
  three
};

Ce code générique fera l'affaire, assez efficacement - placé dans un en-tête générique, il vous servira pour toute énumération que vous pourriez avoir besoin de parcourir:

#include <type_traits>
template < typename C, C beginVal, C endVal>
class Iterator {
  typedef typename std::underlying_type<C>::type val_t;
  int val;
public:
  Iterator(const C & f) : val(static_cast<val_t>(f)) {}
  Iterator() : val(static_cast<val_t>(beginVal)) {}
  Iterator operator++() {
    ++val;
    return *this;
  }
  C operator*() { return static_cast<C>(val); }
  Iterator begin() { return *this; } //default ctor is good
  Iterator end() {
      static const Iterator endIter=++Iterator(endVal); // cache it
      return endIter;
  }
  bool operator!=(const Iterator& i) { return val != i.val; }
};

Vous devrez le spécialiser

typedef Iterator<foo, foo::one, foo::three> fooIterator;

Et puis vous pouvez itérer en utilisant range-for

for (foo i : fooIterator() ) { //notice the parentheses!
   do_stuff(i);
}

L'hypothèse selon laquelle vous n'avez pas de lacunes dans votre énumération est toujours vraie; il n'y a aucune hypothèse sur le nombre de bits réellement nécessaires pour stocker la valeur d'énumération (grâce à std :: sous-jacent_type)

trop compliqué ces solution, j'aime ça:

enum NodePosition { Primary = 0, Secondary = 1, Tertiary = 2, Quaternary = 3};

const NodePosition NodePositionVector[] = { Primary, Secondary, Tertiary, Quaternary };

for (NodePosition pos : NodePositionVector) {
...
}

Je le fais souvent comme ça

    enum EMyEnum
    {
        E_First,
        E_Orange = E_First,
        E_Green,
        E_White,
        E_Blue,
        E_Last
    }

    for (EMyEnum i = E_First; i < E_Last; i = EMyEnum(i + 1))
    {}

ou sinon successif, mais avec pas régulier (par exemple drapeaux de bits)

    enum EAnimalCaps
    {
        E_First,
        E_None    = E_First,
        E_CanFly  = 0x1,
        E_CanWalk = 0x2
        E_CanSwim = 0x4,
        E_Last
    }

    class MyAnimal
    {
       EAnimalCaps m_Caps;
    }

    class Frog
    {
        Frog() : 
            m_Caps(EAnimalCaps(E_CanWalk | E_CanSwim))
        {}
    }

    for (EAnimalCaps= E_First; i < E_Last; i = EAnimalCaps(i << 1))
    {}

Vous ne pouvez pas avec une énumération. Peut-être qu'un enum n'est pas le mieux adapté à votre situation.

Une convention courante consiste à nommer la dernière valeur d'énumération quelque chose comme MAX et à l'utiliser pour contrôler une boucle à l'aide d'un int.

Quelque chose qui n'a pas été couvert dans les autres réponses = si vous utilisez des énumérations C ++ 11 fortement typées, vous ne pouvez pas les utiliser ++ni les utiliser + int. Dans ce cas, une solution un peu plus compliquée est requise:

enum class myenumtype {
  MYENUM_FIRST,
  MYENUM_OTHER,
  MYENUM_LAST
}

for(myenumtype myenum = myenumtype::MYENUM_FIRST;
    myenum != myenumtype::MYENUM_LAST;
    myenum = static_cast<myenumtype>(static_cast<int>(myenum) + 1)) {

  do_whatever(myenum)

}

Vous pouvez essayer de définir la macro suivante:

#define for_range(_type, _param, _A1, _B1) for (bool _ok = true; _ok;)\
for (_type _start = _A1, _finish = _B1; _ok;)\
    for (int _step = 2*(((int)_finish)>(int)_start)-1;_ok;)\
         for (_type _param = _start; _ok ; \
 (_param != _finish ? \
           _param = static_cast<_type>(((int)_param)+_step) : _ok = false))

Vous pouvez maintenant l'utiliser:

enum Count { zero, one, two, three }; 

    for_range (Count, c, zero, three)
    {
        cout << "forward: " << c << endl;
    }

Il peut être utilisé pour parcourir en avant et en arrière à travers des entiers, des énumérations et des caractères non signés:

for_range (unsigned, i, 10,0)
{
    cout << "backwards i: " << i << endl;
}


for_range (char, c, 'z','a')
{
    cout << c << endl;
}

Malgré sa définition maladroite, il est très bien optimisé. J'ai regardé le désassembleur dans VC ++. Le code est extrêmement efficace. Ne vous découragez pas mais les trois pour les instructions: le compilateur ne produira qu'une seule boucle après optimisation! Vous pouvez même définir des boucles fermées:

unsigned p[4][5];

for_range (Count, i, zero,three)
    for_range(unsigned int, j, 4, 0)
    {   
        p[i][j] = static_cast<unsigned>(i)+j;
    }

Vous ne pouvez évidemment pas parcourir les types énumérés avec des lacunes.

Vous pouvez également surcharger les opérateurs d'incrémentation / décrémentation pour votre type énuméré.

En supposant que l'énumération est numérotée séquentiellement, les erreurs sont sujettes. En outre, vous souhaiterez peut-être parcourir les énumérateurs sélectionnés uniquement. Si ce sous-ensemble est petit, le boucler explicitement pourrait être un choix élégant:

enum Item { Man, Wolf, Goat, Cabbage }; // or enum class

for (auto item : {Wolf, Goat, Cabbage}) { // or Item::Wolf, ...
    // ...
}

Si vous n'aimez pas polluer votre énumération avec un élément COUNT final (car peut-être que si vous utilisez également l'énumération dans un commutateur, le compilateur vous avertira d'un cas manquant COUNT :), vous pouvez le faire:

enum Colour {Red, Green, Blue};
const Colour LastColour = Blue;

Colour co(0);
while (true) {
  // do stuff with co
  // ...
  if (co == LastColour) break;
  co = Colour(co+1);
}

Voici une autre solution qui ne fonctionne que pour les énumérations contiguës. Il donne l'itération attendue, à l'exception de la laideur dans l'incrément, qui est à sa place, car c'est ce qui est cassé en C ++.

enum Bar {
    One = 1,
    Two,
    Three,
    End_Bar // Marker for end of enum; 
};

for (Bar foo = One; foo < End_Bar; foo = Bar(foo + 1))
{
    // ...
}

enum class A {
    a0=0, a3=3, a4=4
};
constexpr std::array<A, 3> ALL_A {A::a0, A::a3, A::a4}; // constexpr is important here

for(A a: ALL_A) {
  if(a==A::a0 || a==A::a4) std::cout << static_cast<int>(a);
}

UNE constexpr std::array peut itérer même des énumérations non séquentielles sans que le tableau soit instancié par le compilateur. Cela dépend de choses comme l'heuristique d'optimisation du compilateur et si vous prenez l'adresse du tableau.

Dans mes expériences, j'ai trouvé que g++9.1 avec -O3optimisera le tableau ci-dessus s'il y a 2 valeurs non séquentielles ou pas mal de valeurs séquentielles (j'ai testé jusqu'à 6). Mais il ne fait cela que si vous avez une ifdéclaration. (J'ai essayé une instruction qui comparait une valeur entière supérieure à tous les éléments d'un tableau séquentiel et elle a aligné l'itération bien qu'aucun ne soit exclu, mais quand j'ai omis l'instruction if, les valeurs ont été mises en mémoire.) Elle a également inséré 5 valeurs d'une énumération non séquentielle dans [un cas | https://godbolt.org/z/XuGtoc] . Je soupçonne que ce comportement étrange est dû à une heuristique profonde liée aux caches et à la prédiction de branche.

Voici un lien vers une simple itération de test sur godbolt qui montre que le tableau n'est pas toujours instancié.

Le prix de cette technique est d'écrire deux fois les éléments enum et de synchroniser les deux listes.

Dans le livre du langage de programmation C ++ de Bjarne Stroustrup, vous pouvez lire qu'il propose de surcharger le operator++pour votre spécifique enum. enumsont des types définis par l'utilisateur et un opérateur de surcharge existe dans le langage pour ces situations spécifiques.

Vous pourrez coder les éléments suivants:

#include <iostream>
enum class Colors{red, green, blue};
Colors& operator++(Colors &c, int)
{
     switch(c)
     {
           case Colors::red:
               return c=Colors::green;
           case Colors::green:
               return c=Colors::blue;
           case Colors::blue:
               return c=Colors::red; // managing overflow
           default:
               throw std::exception(); // or do anything else to manage the error...
     }
}

int main()
{
    Colors c = Colors::red;
    // casting in int just for convenience of output. 
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    return 0;
}

code de test: http://cpp.sh/357gb

Attention que j'utilise enum class. Le code fonctionne bien enumaussi. Mais je préfère enum classcar ils sont fortement typés et peuvent nous empêcher de faire des erreurs au moment de la compilation.

Pour les compilateurs MS:

#define inc_enum(i) ((decltype(i)) ((int)i + 1))

enum enumtype { one, two, three, count};
for(enumtype i = one; i < count; i = inc_enum(i))
{ 
    dostuff(i); 
}

Remarque: c'est beaucoup moins de code que la réponse d'itérateur personnalisé simple.

Vous pouvez le faire fonctionner avec GCC en utilisant typeofau lieu de decltype, mais je n'ai pas ce compilateur à portée de main pour le moment pour être sûr qu'il compile.

typedef enum{
    first = 2,
    second = 6,
    third = 17
}MyEnum;

static const int enumItems[] = {
    first,
    second,
    third
}

static const int EnumLength = sizeof(enumItems) / sizeof(int);

for(int i = 0; i < EnumLength; i++){
    //Do something with enumItems[i]
}

C ++ n'a pas d'introspection, vous ne pouvez donc pas déterminer ce genre de chose au moment de l'exécution.

Si vous saviez que les valeurs d'énumération étaient séquentielles, par exemple l'énumération Qt: Key, vous pourriez:

Qt::Key shortcut_key = Qt::Key_0;
for (int idx = 0; etc...) {
    ....
    if (shortcut_key <= Qt::Key_9) {
        fileMenu->addAction("abc", this, SLOT(onNewTab()),
                            QKeySequence(Qt::CTRL + shortcut_key));
        shortcut_key = (Qt::Key) (shortcut_key + 1);
    }
}

Cela fonctionne comme prévu.

Faites simplement un tableau d'entiers et faites une boucle sur le tableau, mais faites le dernier élément dire -1 et utilisez-le pour la condition de sortie.

Si enum est:

enum MyEnumType{Hay=12,Grass=42,Beer=39};

puis créez un tableau:

int Array[] = {Hay,Grass,Beer,-1};

for (int h = 0; Array[h] != -1; h++){
  doStuff( (MyEnumType) Array[h] );
}

Cela ne se décompose pas, peu importe les chiffres de la représentation, tant que le contrôle -1 ne heurte pas l'un des éléments, bien sûr.