Come trasmettere in modo sicuro i tipi interi alle enumerazioni con scope

Question

C++11 enumeriche le enumerazioni dell'ambito sono eccezionali, dovresti usarle quando possibile. Tuttavia, a volte è necessario convertire un numero intero in un valore enum dell'ambito (ad esempio se lo si ottiene dall'input dell'utente).

Esiste un modo sicuro per eseguire questa operazione e rilevare quando il valore non è valido (vale a dire, al di fuori dei valori consentiti dell'enum)?

Credo che usare solo lead statici_cast a comportamento indefinito se il numero intero non è valido. Esiste un modo generico per farlo che non richieda la scrittura di una funzione di conversione per ogni tipo di enume dell'ambito a mano (e che deve essere aggiornato ogni volta che si aggiunge un nuovo valore all'enum)?

Answer 1

Un modo comune per farlo è quello di includere nel vostro enum un marcatore di fine

enum class Colors : char 
{ 
    Red, 
    Green, 
    Blue, 
    Last_Element 
} 

Usando questo approccio, durante la conversione, è possibile controllare se il valore che si sta utilizzando è inferiore al valore di Last_Element .

Si consideri la seguente funzione:

template<typename T> 
typename std::enable_if<std::is_enum<T>::value, bool>::type 
    IsValidEnumIntegral<T>(int integral) 
{ 
    return (int)(T::Last_Element) > integral; 
} 

e si potrebbe usare in questo modo:

if(IsValidEnumIntegral<Colors>(2)) 
    //do whatever 

Questo potrebbe funzionare per qualsiasi enum che hai fatto con un elemento chiamato Last_Element. Potresti andare oltre per creare una funzione simile per poi convertirti automaticamente per te.

Nota: questo non è testato. Al momento non sono in grado di farlo, ma penso che potrebbe funzionare.

EDIT: Funzionerà solo se l'enumerazione in questione utilizza un insieme di numeri interi senza spazi vuoti per i suoi elementi. La funzione fornita presuppone anche che l'enumerazione non contenga interi negativi, sebbene un First_Element possa essere facilmente aggiunto ad esso.

Answer 2

[dcl.enum]/8:

Per un'enumerazione cui tipo sottostante è fisso, i valori della censimento sono i valori del tipo sottostante.

Questo include tutti scope enumerazioni, perché il tipo sottostante di un enum di ambito default per int:

Il tipo sottostante può essere specificato esplicitamente utilizzando un enum base. Per un tipo di enumerazione con ambito, il tipo sottostante è int se non è specificato . In entrambi i casi, il tipo sottostante è detto fisso.

Così, verificando che il valore di ingresso è compreso nell'intervallo di tipo sottostante dell'enumerazione (che è possibile controllare con std::numeric_limits e std::underlying_type), si può essere certi che il static_cast avrà sempre un comportamento ben definito .

Tuttavia, ciò non è sufficiente se il resto del programma non è pronto a gestire ogni valore compreso nell'intervallo del tipo sottostante all'enumerazione. In tal caso, dovrai convalidare te stesso, possibilmente con qualcosa sulla falsariga della risposta di @ Altainia.

Answer 3

Un altro modo in cui ho visto questo tipo di cose fatte in alcune codebase è, fondamentalmente, usare un tratto di tipo per decorare le enumerazioni con scope con informazioni extra.

L'idea è che si avrebbe qualche tratto come

namespace mpl { 
    template <typename T> 
    struct GetEnumData; 
} 

Poi, quando si dichiara un'enum "intelligente", sarà anche specializzarsi questo tratto di collegarsi a una struttura che contiene metadati sul enum con ambito , come quello che sono i valori legali. Oppure, un elenco di stringhe corrispondenti ai nomi dei valori enum, in modo da poter eseguire la conversione enum-to-string e viceversa.

enum class my_enum { a, b, c }; 
namespace mpl { 
    template<> 
    struct GetEnumData<my_enum> { 
    static constexpr std::size_t my_number = 3; 
    static const char * const my_strings []() { 
     return {"a", "b", "c"}; 
    } 
    static const int my_values []() { 
     return {0, 1, 2}; 
    } 
    } 
} // end namespace mpl 

N.B. Generare il tipo di carattere sopra è un po 'noioso, quindi invariabilmente, si finisce per utilizzare alcune macro per le dichiarazioni "smart enum". Se davvero non ti piacciono le macro, questo approccio non fa per te. Almeno fino a quando C++ aggiunge alcune funzionalità di introspezione nelle versioni future (dita incrociate).

Una volta che si dispone di questo tipo di tratto, è possibile fare cose utili come "enum_cast" che analizzerà una stringa per un enum, per esempio.

template <typename T> 
T enum_cast(const std::string & input) { 
    using data = GetEnumData<T>; 

    for (std::size_t idx = 0; idx < data::my_number; ++idx) { 
    if (data::my_strings()[idx] == input) { 
     return static_cast<T>(data::my_values()[idx]); 
    } 
    } 
    throw bad_enum_value(input); 
} 

E si potrebbe fare qualcosa di simile per int 's o altri tipi integrali.