counter c++

(¿Cómo puedo contar los artículos en una enumeración?

Question

Me vino a la mente esta pregunta cuando tuve algo así 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 para volver 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 Carpetas? (Sin depender de, por ejemplo, que FC sea ​​el último elemento de la lista que permita algo como ContainerClass*m_containers[FC+1] si no me equivoco).

Answer 1

¿Qué hay de los rasgos, de una manera 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 aserciones estáticas para mantener las restricciones que std :: numeric_limits :: max () = last_item.

Answer 2

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];

Answer 3

Me gusta usar enumeraciones como argumentos para mis funciones. Es un medio fácil de proporcionar una lista fija de "opciones". El problema con la respuesta más votado aquí es que al usar eso, un cliente puede especificar una "opción inválida". Como spin-off, recomiendo hacer esencialmente lo mismo, pero use una constante int 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.

Answer 4

Para C ++, hay varias técnicas enum de tipo seguro disponibles, y algunas de ellas (como Boost.Enum propuesto pero nunca presentado) 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 de declarar un ... valor MAX para cada uno de sus tipos enum:

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} frente a {FA, FB, FC, Folders_MAX] : prefiero establecer el ... valor MAX en el ú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_MAX proporciona el máximo valor de enum posible).
2. Personalmente, siento que Folders_MAX = FC destaca de otras entradas un poco más (por lo que es un poco más difícil agregar accidentalmente valores enum sin actualizar el valor máximo, un problema al que hace referencia Martin York).
3. GCC incluye advertencias útiles como "valor de enumeración no incluido en el interruptor" para el código, como el siguiente. Letting 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.

switch (folder) { case FA: ...; case FB: ...; // Oops, forgot FC! }

Answer 5

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];

Aún así no es muy agradable.

Pero, por supuesto, te das 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 enum estarían fuera del rango de índice de la matriz. El uso de valores enum para la indexación de matrices no es seguro, debe considerar otras opciones.

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

Answer 6

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

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

en este ejemplo, el resultado crearía una matriz de 3 elementos cuando necesita una matriz de 5 elementos

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

En este ejemplo, 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 aún no está en el estándar, por lo que sé