(¿Cómo) puedo contar los elementos en una enumeración?

Esta pregunta vino a mi mente, cuando tuve algo como

enum Folders {FA, FB, FC};

y quería crear una matriz de contenedores para cada carpeta:

ContainerClass*m_containers[3];
....
m_containers[FA] = ...; // etc.

(Usar mapas es mucho más elegante de usar: std::map<Folders, ContainerClass*> m_containers; )

Pero volviendo a mi pregunta original: ¿Qué pasa si no quiero codificar el tamaño de la matriz? ¿Hay alguna manera de averiguar cuántos elementos hay en las carpetas? (Sin depender, por ejemplo, de FCser el último elemento de la lista que permitiría algo como ContainerClass*m_containers[FC+1]si no me equivoco).

Realmente no hay una buena manera de hacer esto, generalmente ves un elemento adicional en la enumeración, es decir

enum foobar {foo, bar, baz, quz, FOOBAR_NR_ITEMS};

Entonces puedes hacer:

int fuz[FOOBAR_NR_ITEMS];

Aunque todavía no es muy agradable.

Pero, por supuesto, se da cuenta de que solo el número de elementos en una enumeración no es seguro, dado, por ejemplo,

enum foobar {foo, bar = 5, baz, quz = 20};

el número de elementos sería 4, pero los valores enteros de los valores de enumeración estarían fuera del rango del índice de la matriz. El uso de valores de enumeración para la indexación de matrices no es seguro, debe considerar otras opciones.

editar: según lo solicitado, hizo que la entrada especial sobresaliera más.

Para C ++, hay varias técnicas de enumeración con seguridad de tipos disponibles, y algunas de ellas (como el Boost.Enum propuesto pero nunca enviado ) incluyen soporte para obtener el tamaño de una enumeración.

El enfoque más simple, que funciona tanto en C como en C ++, es adoptar una convención para declarar un valor ... MAX para cada uno de sus tipos de enumeración:

enum Folders { FA, FB, FC, Folders_MAX = FC };
ContainerClass *m_containers[Folders_MAX + 1];
....
m_containers[FA] = ...; // etc.

Editar : Con respecto a { FA, FB, FC, Folders_MAX = FC}versus {FA, FB, FC, Folders_MAX]: prefiero establecer el valor ... MAX al último valor legal de la enumeración por algunas razones:

1. El nombre de la constante es técnicamente más preciso (ya que Folders_MAXda el máximo valor de enumeración posible).
2. Personalmente, me siento como Folders_MAX = FC destaca un poco más de otras entradas (lo que hace que sea un poco más difícil agregar accidentalmente valores de enumeración sin actualizar el valor máximo, un problema al que Martin York hizo referencia).
3. GCC incluye advertencias útiles como "valor de enumeración no incluido en el conmutador" para códigos como el siguiente. Dejar Folders_MAX == FC + 1 rompe esas advertencias, ya que terminas con un montón de ... MAX valores de enumeración que nunca deberían incluirse en el cambio.

cambiar (carpeta) 
{
  caso FA: ...;
  caso FB: ...;
  // ¡Ups, me olvidé de FC!
}

¿Qué hay de los rasgos, en estilo STL? Por ejemplo:

enum Foo
{
    Bar,
    Baz
};

escribe un

std::numeric_limits<enum Foo>::max()

especialización (posiblemente constexpr si usa c ++ 11). Luego, en su código de prueba, proporcione cualquier aserción estática para mantener las restricciones que std :: numeric_limits :: max () = last_item.

Agregue una entrada, al final de su enumeración, llamada Folders_MAX o algo similar y use este valor al inicializar sus matrices.

ContainerClass* m_containers[Folders_MAX];

Me gusta usar enumeraciones como argumentos para mis funciones. Es un medio sencillo para proporcionar una lista fija de "opciones". El problema con la respuesta más votada aquí es que al usarla, un cliente puede especificar una "opción no válida". Como un derivado, recomiendo hacer esencialmente lo mismo, pero usar un int constante fuera de la enumeración para definir el recuento de ellos.

enum foobar { foo, bar, baz, quz };
const int FOOBAR_NR_ITEMS=4;

No es agradable, pero es una solución limpia si no cambia la enumeración sin actualizar la constante.

Realmente no veo ninguna forma de llegar realmente al número de valores en una enumeración en C ++. Cualquiera de las soluciones mencionadas anteriormente funciona siempre que no defina el valor de sus enumeraciones si define su valor que podría encontrarse en situaciones en las que crea matrices demasiado grandes o demasiado pequeñas

enum example{ test1 = -2, test2 = -1, test3 = 0, test4 = 1, test5 = 2 }

en esto sobre ejemplos, el resultado crearía una matriz de 3 elementos cuando necesite una matriz de 5 elementos

enum example2{ test1 , test2 , test3 , test4 , test5 = 301 }

en esto sobre ejemplos, el resultado crearía una matriz de 301 elementos cuando necesite una matriz de 5 elementos

La mejor manera de resolver este problema en el caso general sería iterar a través de sus enumeraciones, pero eso no está en el estándar hasta donde yo sé