Détecter si la conversion d'un int en enum entraîne une valeur non énumérée

CashCow présente un décent répondre à cette question: c'est certainement simple à écrire une fonction personnalisée d'effectuer un contrôle de fonte.

Malheureusement, c'est aussi beaucoup de travail et vous devez vous assurer de le garder synchronisés avec l'énumération de sorte que la liste des agents recenseurs dans l'énumération définition est la même que la liste des agents recenseurs dans les bagages fonction de distribution. Vous devez également écrire un de ces pour chaque énumération à laquelle vous souhaitez être en mesure d'effectuer un contrôle de fonte.

Plutôt que de faire tout ce travail manuel, nous pouvons automatiser la génération de l'ensemble de ce code en utilisant le préprocesseur (avec un peu d'aide de l'augmentation de Préprocesseur de la bibliothèque). Voici une macro qui génère une énumération définition avec une checked_enum_cast fonction. C'est sans doute un peu effrayant à la recherche (génération de code macros sont souvent horrible à regarder), mais il est extrêmement utile de se familiariser avec.

#include <stdexcept>
#include <boost/preprocessor.hpp>

//Internal helper to provide partial specialization for checked_enum_cast
template <typename Target, typename Source>
struct checked_enum_cast_impl;

//Exception thrown by checked_enum_cast on cast failure
struct invalid_enum_cast : std::out_of_range 
{ 
    invalid_enum_cast(const char* s)
        : std::out_of_range(s) { }
};

//Checked cast function
template <typename Target, typename Source>
Target checked_enum_cast(Source s)
{
    return checked_enum_cast_impl<Target, Source>::do_cast(s);
}

//Internal helper to help declare case labels in the checked cast function
#define X_DEFINE_SAFE_CAST_CASE(r, data, elem) case elem:

//Macro to define an enum with a checked cast function.  name is the name of 
//the enumeration to be defined and enumerators is the preprocessing sequence
//of enumerators to be defined.  See the usage example below.
#define DEFINE_SAFE_CAST_ENUM(name, enumerators)                           \
    enum name                                                              \
    {                                                                      \
        BOOST_PP_SEQ_ENUM(enumerators)                                     \
    };                                                                     \
                                                                           \
    template <typename Source>                                             \
    struct checked_enum_cast_impl<name, Source>                            \
    {                                                                      \
        static name do_cast(Source s)                                      \
        {                                                                  \
            switch (s)                                                     \
            {                                                              \
            BOOST_PP_SEQ_FOR_EACH(X_DEFINE_SAFE_CAST_CASE, 0, enumerators) \
                return static_cast<name>(s);                               \
            default:                                                       \
                throw invalid_enum_cast(BOOST_PP_STRINGIZE(name));         \
            }                                                              \
            return name();                                                 \
        }                                                                  \
    };

Voici comment vous pouvez l'utiliser avec votre CardColor exemple:

DEFINE_SAFE_CAST_ENUM(CardColor, (HEARTS) (CLUBS) (SPADES) (DIAMONDS))

int main()
{
    checked_enum_cast<CardColor>(1);   //ok
    checked_enum_cast<CardColor>(400); //o noez!  an exception!
}

La première ligne remplace votre enum CardColor ... définition; il définit l'énumération et offre une spécialisation qui vous permet d'utiliser checked_enum_cast de jeter des entiers CardColor.

Cela peut ressembler à beaucoup de tracas juste pour obtenir un activée fonction de distribution pour votre enums, mais cette technique est très utile et très extensible. Vous pouvez ajouter des fonctions que de faire toutes sortes de choses. Par exemple, j'en ai un qui génère les fonctions de convertir les types énumérés et de la chaîne des représentations et des fonctions qui effectuent plusieurs autres conversions et vérifie que j'utilise pour la plupart de mes énumérations.

Rappelez-vous, vous avez à écrire et déboguer des gros, laid macro une fois seulement, puis vous pouvez l'utiliser partout.

clang du support de la dynamique de dépassement des contrôles. Voir -fsanitize=enum commutateur. Un programme compilé avec ce commutateur de signal enum affectation des erreurs grâce à l'stderr de sortie. Cela vous permettra de faire des tests de débogage. Il n'est pas adapté pour tester suspect entrée officielle à construire.

Au début - c'est une mauvaise idée de faire cela.

Mais si vous voulez, je vous suggère de coder en dur entier les valeurs de l'énumération:

enum CardColor { HEARTS = 10, DIAMONDS = 11, CLUBS = 12, SPADES = 13};

Puis la surcharge de l'affectation de l'opérateur:

CardColor operator = (int value)
{
    switch (value)
    {
        case 10:
            return HEARTS;
        //case for other values
        default:
            //throw an exception or something
    }
}