modo ottimizzato per verificare il valore di una variabile con un valore membri enum

Question

Ciao Ho il codice qui sotto:

enum {a, b, c, d, ..., z} abc; 

int main() 
{ 
    int val = 20; 
    if (val == a || val == b ||val == c||val == d..... || val == z) 
    { 
    /*Do something*/ 
    } 
} 

C'è un altro modo in modo che possiamo saltare l'operazione OR perché se ci sono 1000 di enum i membri quindi come possiamo fare avanti con il controllo con tutti i membri. Per favore aiuto.

Answer 1

Poiché i valori di enumerazione vengono assegnati in sequenza, mettendo un'istruzione if come questo sarebbe sufficiente:

if (val < = z)

Answer 2

Si potrebbe utilizzare una mappa in C++. Con una mappa è possibile scrivere un test compatto senza i numerosi == e ||.

Ma per prima cosa è necessario inizializzare una mappa e non sono sicuro di poter eseguire questa inizializzazione in modo compatto per un enum arbitrario.

#include <iostream> 
#include <map> 

using namespace std; 

enum abc { a = 1, b = -1, c = 3, d = 0 }; 

int main() 
{ 
    map<int, int> m; 
    m[a] = m[b] = m[c] = m[d] = 1; 
    cout << "b is " << ((m.find(b) == m.end()) ? "NOT " : "") << "in m" << endl; 
    cout << "3 is " << ((m.find(3) == m.end()) ? "NOT " : "") << "in m" << endl; 
    cout << "10 is " << ((m.find(10) == m.end()) ? "NOT " : "") << "in m" << endl; 
    return 0; 
} 

uscita (ideone):

b is in m 
3 is in m 
10 is NOT in m 

Answer 3

Un compilatore moderno dovrebbe solo essere in grado di ottimizzare tale codice, se, come nel suo caso, il valore dell'espressione è noto al momento della compilazione. Per facilitare la lettura e la verifica degli errori penso che usare un switch sarebbe meglio:

switch (val) { 
case a:; 
case b:; 
.... 
// your code goes here 
} 

Come detto, le prestazioni saggio non dovrebbe esistere molta differenza, il compilatore trasformerà questo per una ricerca tabella (o altre cose intelligenti) se appropriato o completamente ottimizzato se val è noto al momento della compilazione.

Ma si può avere il vantaggio di compilare i compilatori di errori, qui. Se non si dispone di un caso default, la maggior parte dei compilatori avviserà l'utente se si omette una delle costanti di enumerazione. Inoltre, penso che questo sia più chiaro, dal momento che non ripete la valutazione di val dappertutto.

Answer 4

altra soluzione (più veloce) sarà il seguente

bool isInenum (int val) 
{ 
    bool retVal = false 
     switch(val) 

    { 
     case a: 
     case b: 
     case c: 
     case d: 
      { 
       retVal = true; 
      } 

    } 
    return retVal; 
}