c++ - uso - utilizar enum en java

El método más simple para iterar a través de valores de enumeración contiguos en C++

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo puedo iterar sobre una enumeración? 17 respuestas

¿Cuál es el método simple preferido para iterar a través de una enumeración con valores contiguos en C ++? Encontré preguntas de SO previas sobre este tema, que implicaban la creación de un operator++ personalizado operator++ etc., pero esto parece una exageración. Hasta ahora lo mejor que he encontrado es:

enum {
   FOO,
   BAR,
   BLECH,
   NUM_ENUMS
} MyEnum;

//for (MyEnum m = FOO; m < NUM_ENUMS; ++m)             // compile error
//    ...

//for (MyEnum m = FOO; m < NUM_ENUMS; m = m + 1)       // compile error
//    ...

for (MyEnum m = FOO; m < NUM_ENUMS; m = MyEnum(m + 1)) // OK ?
    ...

¿Es esto razonable desde una perspectiva de estilo de codificación y es probable que genere advertencias ( g++ -Wall ... parece estar contento con esto)?

Answer 1

Como dijo Matthieu, es perfectamente seguro hacerlo y no va en contra del estándar C ++ de ninguna manera.

Como una sobrecarga de notas laterales, el operador ++ sobre la enumeración no solo es una exageración, sino que también tiene problemas ya establecidos por otros (por ejemplo, si la enumeración no es lineal en los valores)

Por lo tanto, en lugar de definir un operador ++, lo que necesita es un iterador.

Desde aquí adapté la siguiente solución con respecto a enumerados por deft_code pero ligeramente adaptado a su ejemplo.

template< typename T >
class Enum
{
public:
   class Iterator
   {
   public:
  Iterator( int value ) :
     m_value( value )
  { }

  T operator*( void ) const
  {
     return (T)m_value;
  }

  void operator++( void )
  {
     ++m_value;
  }

  bool operator!=( Iterator rhs )
  {
     return m_value != rhs.m_value;
  }

   private:
      int m_value;
   };

};

template< typename T >
typename Enum<T>::Iterator begin( Enum<T> )
{
   return typename Enum<T>::Iterator( (int)T::First );
}

template< typename T >
typename Enum<T>::Iterator end( Enum<T> )
{
   return typename Enum<T>::Iterator( ((int)T::Last) + 1 );
}

enum class MyEnum
{
   FOO,
   BAR,
   BLECH,
   NUM_ENUMS
};

int main()
{
   for( auto e: Enum<MyEnum>() )
   {
      std::cout << ((int)e) << std::endl;
   }
}

Esto todavía puede ser una exageración para usted, pero es mucho más limpio. Otra pieza de código pero un enfoque mucho más elegante está here . Es posible que en el futuro las clases de enumeración introducidas en C ++ 11 tengan un iterador en el estándar.

actualización: ya que nos ha informado de que sus valores son contiguos y el hecho de que se requiere para una API de C (?), entonces lo anterior no será adecuado.

Answer 2

De hecho es seguro.

Esto habría sido indefinido: MyEnum(int(NUM_ENUMS) + 1) porque el valor a mantener (4) sería mayor que lo que puede representar la enumeración ([0, 3]); ya que se asegura de que m sea ​​estrictamente inferior a NUM_ENUMS , es seguro usar MyEnum(m + 1) .

Por otro lado, tenga en cuenta que tendría problemas con enumeraciones personalizadas como:

enum OtherEnum {
    Foo = -1,
    Bar = 2,
    Baz = 8,
    NUM_OTHERENUM
};

por lo que no es una práctica genérica.

Recomendaría una matriz generada para iterar sobre:

MyEnum const Values[] = { FOO, BAR, BLECH };

Tenga en cuenta que se genera fácilmente a partir de la definición de la enumeración y también evite contaminar la interfaz con un valor sin sentido (a nivel comercial).