Moyen générique de cast int enum en C++

La chose la plus évidente consiste à annoter votre enum:

//generic code
#include <algorithm>

template <typename T>
struct enum_traits {};

template<typename T, size_t N>
T *endof(T (&ra)[N]) {
    return ra + N;
}

template<typename T, typename ValType>
T check(ValType v) {
    typedef enum_traits<T> traits;
    const T *first = traits::enumerators;
    const T *last = endof(traits::enumerators);
    if (traits::sorted) { //probably premature optimization
        if (std::binary_search(first, last, v)) return T(v);
    } else if (std::find(first, last, v) != last) {
        return T(v);
    }
    throw "exception";
}

//"enhanced" definition of enum
enum e {
    x = 1,
    y = 4,
    z = 10,
};

template<>
struct enum_traits<e> {
    static const e enumerators[];
    static const bool sorted = true;
};
//must appear in only one TU,
//so if the above is in a header then it will need the array size
const e enum_traits<e>::enumerators[] = {x, y, z};

//usage
int main() {
    e good = check<e>(1);
    e bad = check<e>(2);
}

Vous avez besoin de la matrice pour être tenu à jour avec e, qui est une nuisance si vous n'êtes pas l'auteur de e. Comme Sjoerd dit, il peut probablement être automatisé à l'aide de tout bon système de construction.

Dans tous les cas, vous êtes contre 7.2/6:

Pour une énumération où emin est l'
le plus petit agent recenseur et emax est l'
plus grand, les valeurs de l'énumération
sont les valeurs du type sous-jacent
dans la gamme bmin à bmax, où bmin
et bmax sont, respectivement, la
la plus petite et la plus grande des valeurs de la
plus petit champ qui permet de stocker emin
et emax. Il est possible de définir une
l'énumération qui a des valeurs non
défini par l'une quelconque de ses agents recenseurs.

Donc, si vous n'êtes pas l'auteur de e, vous peut ou peut ne pas avoir la garantie que les valeurs valides de e fait apparaître dans sa définition.

Si, comme vous le décrivez, les valeurs sont dans une base de données, pourquoi ne pas écrire un générateur de code qui lit ce tableau et crée un .h et .rpc fichier avec les enum et un to_enum(int) fonction?

Avantages:

• Facile d'ajouter un to_string(my_enum) fonction.
• Peu d'entretien nécessaire
• Base de données et le code sont en phase

Que pensez-vous de celui-ci?

#include <iostream>
#include <stdexcept>
#include <set>
#include <string>
using namespace std;
template<typename T>
class Enum
{
public:
static void insert(int value)
{
_set.insert(value);
}
static T buildFrom(int value)
{
if (_set.find(value) != _set.end()) {
T retval;
retval.assign(value);
return retval;
}
throw std::runtime_error("unexpected value");
}
operator int() const { return _value; }
private:
void assign(int value)
{
_value = value;
}
int _value;
static std::set<int> _set;
};
template<typename T> std::set<int> Enum<T>::_set;
class Apples: public Enum<Apples> {};
class Oranges: public Enum<Oranges> {};
class Proxy
{
public:
Proxy(int value): _value(value) {}
template<typename T>
operator T()
{
T theEnum;
return theEnum.buildFrom(_value);
}
int _value;
};
Proxy convert(int value)
{
return Proxy(value);
}
int main()
{    
Apples::insert(4);
Apples::insert(8);
Apples a = convert(4); //works
std::cout << a << std::endl; //prints 4
try {
Apples b = convert(9); //throws    
}
catch (std::exception const& e) {
std::cout << e.what() << std::endl; //prints "unexpected value"
}
try {
Oranges b = convert(4); //also throws  
}
catch (std::exception const& e) {
std::cout << e.what() << std::endl; //prints "unexpected value"
}
}

Vous pouvez ensuite utiliser le code que j'ai posté ici pour basculer sur les valeurs.

Si vous êtes prêt à la liste de vos valeurs enum comme paramètres de modèle, vous pouvez le faire en C++ 11 avec varadic modèles. Vous pouvez voir cela comme une bonne chose, vous permettant d'accepter des sous-ensembles de l'valide les valeurs de l'enum dans différents contextes; souvent utile lors de l'analyse des codes à partir de sources externes.

Peut-être pas tout à fait aussi générique que vous le souhaitez, mais le code de vérification lui-même est généralisé, il vous suffit de spécifier le jeu de valeurs. Cette approche gère des lacunes, des valeurs arbitraires, etc.

template<typename EnumType, EnumType... Values> class EnumCheck;
template<typename EnumType> class EnumCheck<EnumType>
{
public:
template<typename IntType>
static bool constexpr is_value(IntType) { return false; }
};
template<typename EnumType, EnumType V, EnumType... Next>
class EnumCheck<EnumType, V, Next...> : private EnumCheck<EnumType, Next...>
{
using super = EnumCheck<EnumType, Next...>;
public:
template<typename IntType>
static bool constexpr is_value(IntType v)
{
return v == static_cast<typename std::underlying_type<EnumType>::type>(V) || super::is_value(v);
}
EnumType convert(IntType v)
{
if (!is_value(v)) throw std::runtime_error("Enum value out of range");
return static_cast<EnumType>(v);
};
enum class Test {
A = 1,
C = 3,
E = 5
};
using TestCheck = EnumCheck<Test, Test::A, Test::C, Test::E>;
void check_value(int v)
{
if (TestCheck::is_value(v))
printf("%d is OK\n", v);
else
printf("%d is not OK\n", v);
}
int main()
{
for (int i = 0; i < 10; ++i)
check_value(i);
}

Essayer quelque chose comme cela:

enum EType
{
type1,
type2
};
unsigned int number = 3;
EType e = static_cast<EType>(number);
if(static_cast<unsigned int>(e) != number)
throw std::exception();