(Como) posso contar os itens em um enum?

Esta questão veio à minha mente, quando eu tinha algo como

enum Folders {FA, FB, FC};

e queria criar uma matriz de contêineres para cada pasta:

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

(Usar mapas é muito mais elegante de usar: std::map<Folders, ContainerClass*> m_containers; :)

Mas, voltando à minha pergunta original: e se eu não quiser codificar o tamanho do array, há uma maneira de descobrir quantos itens estão nas pastas? (Sem depender de, por exemplo, FCser o último item da lista o que permitiria algo como ContainerClass*m_containers[FC+1]se não estou enganado.)

Não há realmente uma boa maneira de fazer isso, geralmente você vê um item extra no enum, ou seja,

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

Então você pode fazer:

int fuz[FOOBAR_NR_ITEMS];

Ainda não é muito bom.

Mas é claro que você percebe que apenas o número de itens em um enum não é seguro, dado, por exemplo,

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

o número de itens seria 4, mas os valores inteiros dos valores enum estariam fora do intervalo do índice da matriz. Usar valores enum para indexação de array não é seguro, você deve considerar outras opções.

editar: conforme solicitado, fez a entrada especial destacar-se mais.

Para C ++, existem várias técnicas de enum de tipo seguro disponíveis, e algumas delas (como o Boost.Enum proposto-mas-nunca-enviado ) incluem suporte para obter o tamanho de um enum.

A abordagem mais simples, que funciona tanto em C quanto em C ++, é adotar uma convenção de declarar um valor ... MAX para cada um de seus tipos de enum:

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

Editar : Quanto { FA, FB, FC, Folders_MAX = FC}contra {FA, FB, FC, Folders_MAX]: Eu prefiro definir o ... valor MAX para o último valor legal do enum por algumas razões:

1. O nome da constante é tecnicamente mais preciso (uma vez que Folders_MAXfornece o valor enum máximo possível).
2. Pessoalmente, sinto que Folders_MAX = FC se destaca um pouco mais das outras entradas (tornando um pouco mais difícil adicionar acidentalmente valores enum sem atualizar o valor máximo, um problema mencionado por Martin York).
3. O GCC inclui avisos úteis como "valor de enumeração não incluído na opção" para códigos como o seguinte. Permitir que Folders_MAX == FC + 1 quebra esses avisos, uma vez que você acaba com um monte de ... valores de enumeração MAX que nunca devem ser incluídos na opção.

mudar (pasta) 
{
  caso FA: ...;
  caso FB: ...;
  // Ops, esqueci o FC!
}

Que tal traços, em estilo STL? Por exemplo:

enum Foo
{
    Bar,
    Baz
};

escrever um

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

especialização (possivelmente constexpr se você usar c ++ 11). Então, em seu código de teste forneça quaisquer asserções estáticas para manter as restrições que std :: numeric_limits :: max () = last_item.

Adicione uma entrada, no final de seu enum, chamada Folders_MAX ou algo semelhante e use esse valor ao inicializar seus arrays.

ContainerClass* m_containers[Folders_MAX];

Gosto de usar enums como argumentos para minhas funções. É um meio fácil de fornecer uma lista fixa de "opções". O problema com a resposta mais votada aqui é que, usando-a, um cliente pode especificar uma "opção inválida". Como um spin off, recomendo fazer essencialmente a mesma coisa, mas usar um int constante fora do enum para definir a contagem deles.

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

Não é agradável, mas é uma solução limpa se você não alterar o enum sem atualizar a constante.

Eu realmente não vejo nenhuma maneira de realmente obter o número de valores em uma enumeração em C ++. Qualquer uma das soluções antes mencionadas funciona, desde que você não defina o valor de suas enumerações se você definir seu valor que poderá se deparar com situações em que criará matrizes muito grandes ou muito pequenas

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

neste exemplo, o resultado criaria um array de 3 itens quando você precisa de um array de 5 itens

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

neste exemplo, o resultado criaria uma matriz de 301 itens quando você precisa de uma matriz de 5 itens

A melhor maneira de resolver este problema no caso geral seria iterar por meio de suas enumerações, mas isso não está no padrão até onde eu sei