(Come) posso contare gli elementi in un'enumerazione?

Questa domanda mi è venuta in mente, quando ho avuto qualcosa di simile

enum Folders {FA, FB, FC};

e volevo creare una serie di contenitori per ogni cartella:

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

(Usare le mappe è molto più elegante da usare std::map<Folders, ContainerClass*> m_containers;:)

Ma per tornare alla mia domanda originale: cosa succede se non voglio codificare in modo rigido la dimensione dell'array, c'è un modo per capire quanti elementi ci sono nelle cartelle? (Senza fare affidamento, ad esempio, FCsull'essere l'ultimo elemento della lista che consentirebbe qualcosa di simile ContainerClass*m_containers[FC+1]se non mi sbaglio.)

Non c'è davvero un buon modo per farlo, di solito vedi un elemento in più nell'enumerazione, ad es

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

Quindi puoi fare:

int fuz[FOOBAR_NR_ITEMS];

Comunque non è ancora molto carino.

Ma ovviamente ti rendi conto che solo il numero di elementi in un enum non è sicuro, dato ad es

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

il numero di elementi sarebbe 4, ma i valori interi dei valori enum sarebbero fuori dall'intervallo dell'indice dell'array. L'uso dei valori enum per l'indicizzazione di array non è sicuro, dovresti considerare altre opzioni.

modifica: come richiesto, fa risaltare maggiormente la voce speciale.

Per C ++, sono disponibili varie tecniche enum indipendenti dai tipi e alcune di esse (come Boost.Enum proposto ma mai inviato ) includono il supporto per ottenere le dimensioni di un'enumerazione.

L'approccio più semplice, che funziona sia in C che in C ++, è quello di adottare una convenzione per dichiarare un valore ... MAX per ciascuno dei tipi di enumerazione:

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

Modifica : per quanto riguarda { FA, FB, FC, Folders_MAX = FC}versus {FA, FB, FC, Folders_MAX]: preferisco impostare il ... valore MAX sull'ultimo valore legale dell'enumerazione per alcuni motivi:

1. Il nome della costante è tecnicamente più accurato (poiché Folders_MAXfornisce il massimo valore di enum possibile).
2. Personalmente, mi sento come Folders_MAX = FC si distinguesse un po 'di più dalle altre voci (rendendo un po' più difficile aggiungere accidentalmente valori enum senza aggiornare il valore massimo, un problema a cui fa riferimento Martin York).
3. GCC include utili avvisi come "valore di enumerazione non incluso nello switch" per codice come il seguente. Lasciando Folders_MAX == FC + 1 interrompe questi avvertimenti, poiché si finisce con un mucchio di ... MAX valori di enumerazione che non dovrebbero mai essere inclusi in switch.

switch (cartella) 
{
  caso FA: ...;
  caso FB: ...;
  // Oops, ho dimenticato FC!
}

Che ne dici dei tratti, in modo STL? Per esempio:

enum Foo
{
    Bar,
    Baz
};

Scrivi un

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

specializzazione (possibilmente constexpr se usi c ++ 11). Quindi, nel codice di test, fornire eventuali asserzioni statiche per mantenere i vincoli che std :: numeric_limits :: max () = last_item.

Aggiungi una voce, alla fine della tua enumerazione, chiamata Folders_MAX o qualcosa di simile e usa questo valore quando inizializzi i tuoi array.

ContainerClass* m_containers[Folders_MAX];

Mi piace usare le enumerazioni come argomenti per le mie funzioni. È un mezzo semplice per fornire un elenco fisso di "opzioni". Il problema con la risposta più votata qui è che usando quella, un cliente può specificare una "opzione non valida". Come spin off, consiglio di fare essenzialmente la stessa cosa, ma usa una costante int al di fuori dell'enum per definirne il conteggio.

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

Non è piacevole, ma è una soluzione pulita se non si modifica l'enumerazione senza aggiornare la costante.

Non vedo davvero alcun modo per ottenere davvero il numero di valori in un'enumerazione in C ++. Qualsiasi soluzione prima menzionata funziona fintanto che non definisci il valore delle tue enumerazioni se definisci un valore che potresti imbatterti in situazioni in cui crei array troppo grandi o troppo piccoli

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

in questo esempio di esempi il risultato creerebbe un array di 3 elementi quando è necessario un array di 5 elementi

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

in questo esempio di esempi il risultato creerebbe un array di 301 elementi quando è necessario un array di 5 elementi

Il modo migliore per risolvere questo problema nel caso generale sarebbe quello di iterare attraverso le tue enumerazioni ma questo non è ancora nello standard per quanto ne so