Uso de enum class. Consejos

[dehm]

Hola:

Me disponía a ensayar con los nuevos tipos enumerados, pero me han entrado dos dudas.

1.- Esta está relacionada con los enum en general, no con los "nuevos" enum

Si me creo un archivo externo sólo para definir tipos enumerados, y que tengan acceso a ellos otras clases, lo hago así:

Código C++:

namespace tipoColumna
{
    enum  {COLUMNA1, COLUMNA2,COLUMNA3,COLUMNA4};
}
 

Definirlos de forma "anónima" es cómodo para hacer uso de ellos, puesto que en otras partes del código me refiero a ellos como:

Código C++:

if (indice.column()==tipoColumna::COLUMNA2)
    {
        --------------------
    }
 

Pero no sé si es buena práctica o no.

Y la otra duda:

2.-Si intento hacer lo mismo con los nuevos tipos enumerados, ya no hay una conversión implícita entre el número y el enumerado. Entonces....¿es posible usar los nuevos tipos enumerados en funciones que aceptan un int como parámetro?
Por ejemplo, el método:

Código C++:

void setItemDelegateForColumn(int column, QAbstractItemDelegate * delegate)
 

no aceptará un enum "de los nuevos", entiendo yo. Por lo que no es este el uso de los nuevos enum (enum class). Pero no sé si estoy equivocado o no.

Saludos y gracias

[eferion]

Iniciado por dehm

Pero no sé si es buena práctica o no.

Los enum class se crearon principalmente para evitar "enums planos", es decir. Si tu tienes un enum tal que:

Código C++:

enum Color
{
  Black,
  White
};
 

Su uso acaba quedando así:

Código C++:

Color color = Black;
 

De tal forma que "Black" puede ser un valor definido en el enum, #define, una variable de tipo int, ... vamos, que una línea de ese tipo no te garantiza que "Black" sea un valor definido en ese enum. Incluso si en algún sitio te encuentras algo tal que:

Código C++:

int color = Black;
 

Puedes asumir erróneamente que "Black" lo está cogiendo del enum... cuando lo que puede suceder es que este valor venga de un #define:

Código C++:

#include <iostream>
 
enum Color
{
  Black,
  White
};
 
#define Black 100
 
int main( )
{
  std::cout << "-" << Black << "-" << std::endl;
}
 

Sin embargo, con los enum class la cosa cambia:

Código C++:

#include <iostream>
 
enum class Color
{
  Black,
  White
};
 
#define Black 100 // <<-- Error de compilación
 
int main( )
{
  std::cout << "-" << Color::Black << "-" << std::endl;
}
 

Incluso, aunque no se produjese el error de compilación, ahora sí queda claro que "Black" es un valor definido en el enum. Y esto será así independientemente de dónde te encuentres el uso de "Color::Black".

Así que bueno, visto lo visto yo te recomiendo usar "enum class" o, en su defecto, evitar en la medida de lo posible los "enum planos". Por cierto, una forma usada para evitar "enums planos" antes de "enum class" es la siguiente:

Código C++:

struct Color
{
  enum Type
  {
    Black,
    White
  };
}
 
int main( )
{
  Color::Type color = Color::Black;
  std::cout << "-" << color << "-" << std::endl;
}
 

Iniciado por dehm

2.-Si intento hacer lo mismo con los nuevos tipos enumerados, ya no hay una conversión implícita entre el número y el enumerado. Entonces....¿es posible usar los nuevos tipos enumerados en funciones que aceptan un int como parámetro?

Que no haya una conversión implícita no quiere decir que no exista una conversión explícita:

Código C++:

#include <iostream>
 
enum class Color
{
  Black,
  White
};
 
int main( )
{
  std::cout << "-" << static_cast<int>(Color::White) << "-" << std::endl;
}
 

Así mismo, que una variable esté definda como "enum class" no le impide tener valores no válidos:

Código C++:

#include <iostream>
 
enum class Color
{
  Black, // 0
  White  // 1
};
 
int main( )
{
  Color color = static_cast<Color>( 23 );
  std::cout << "-" << static_cast<int>(color) << "-" << std::endl;
}
 

Así, en el ejemplo que has puesto, una posible solución seria forzar un cast a int.

Un saludo.

[lareto]

Hola; puedes usar la misma forma de llamada para los dos tipos de enum. Te paso un ejemplo:

Código C++:

#include <iostream>
 
enum X {a = 1, b};
 
enum class tipoColumna {
    COLUMNA1 = 100,
    COLUMNA2,
    COLUMNA3,
    COLUMNA4 };
 
template<typename T>
int int_enum_como_int(T t)
{
    return static_cast<typename std::underlying_type<T>::type>(t);
}
 
void f(int i)
{
    std::cout << i << '\n';
}
 
int main()
{
    f(int_enum_como_int(tipoColumna::COLUMNA1));
    f(int_enum_como_int(a));
}