Comment utiliser les enums comme drapeaux en C++ ?

Question

Traitement de enum en tant que drapeaux fonctionne bien en C# via l'option [Flags] mais quelle est la meilleure façon de le faire en C++ ?

Par exemple, j'aimerais écrire :

enum AnimalFlags
{
    HasClaws = 1,
    CanFly =2,
    EatsFish = 4,
    Endangered = 8
};

seahawk.flags = CanFly | EatsFish | Endangered;

Cependant, j'obtiens des erreurs de compilation concernant int / enum conversions. Existe-t-il un moyen plus agréable d'exprimer cela que le simple casting brutal ? De préférence, je ne veux pas m'appuyer sur des constructions de bibliothèques tierces telles que boost ou Qt.

EDIT : Comme indiqué dans les réponses, je peux éviter l'erreur de compilation en déclarant seahawk.flags como int . Cependant, j'aimerais disposer d'un mécanisme permettant d'assurer la sécurité des types, afin que quelqu'un ne puisse pas écrire seahawk.flags = HasMaximizeButton .

Answer 1

La méthode "correcte" consiste à définir des opérateurs binaires pour l'enum, comme :

enum AnimalFlags
{
    HasClaws   = 1,
    CanFly     = 2,
    EatsFish   = 4,
    Endangered = 8
};

inline AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
    return static_cast<AnimalFlags>(static_cast<int>(a) | static_cast<int>(b));
}

Etc. le reste des opérateurs de bits. Modifier si nécessaire si l'étendue de l'enum dépasse l'étendue de l'int.

Answer 2

Note (également un peu hors sujet) : Une autre façon de faire des drapeaux uniques peut être faite en utilisant un décalage de bit. Pour ma part, je trouve cette méthode plus facile à lire.

enum Flags
{
    A = 1 << 0, // binary 0001
    B = 1 << 1, // binary 0010
    C = 1 << 2, // binary 0100
    D = 1 << 3  // binary 1000
};

Il peut contenir des valeurs allant jusqu'à un int, c'est-à-dire, la plupart du temps, 32 drapeaux, ce qui se reflète clairement dans le montant du décalage.

Answer 3

Pour les personnes paresseuses comme moi, voici une solution modèle pour le copier-coller :

template<class T> inline T operator~ (T a) { return (T)~(int)a; }
template<class T> inline T operator| (T a, T b) { return (T)((int)a | (int)b); }
template<class T> inline T operator& (T a, T b) { return (T)((int)a & (int)b); }
template<class T> inline T operator^ (T a, T b) { return (T)((int)a ^ (int)b); }
template<class T> inline T& operator|= (T& a, T b) { return (T&)((int&)a |= (int)b); }
template<class T> inline T& operator&= (T& a, T b) { return (T&)((int&)a &= (int)b); }
template<class T> inline T& operator^= (T& a, T b) { return (T&)((int&)a ^= (int)b); }

Answer 4

Notez que si vous travaillez dans l'environnement Windows, il y a une DEFINE_ENUM_FLAG_OPERATORS définie dans winnt.h qui fait le travail pour vous. Donc dans ce cas, vous pouvez faire ceci :

enum AnimalFlags
{
    HasClaws = 1,
    CanFly =2,
    EatsFish = 4,
    Endangered = 8
};
DEFINE_ENUM_FLAG_OPERATORS(AnimalFlags)

seahawk.flags = CanFly | EatsFish | Endangered;

Answer 5

Quel est le type de la variable seahawk.flags ?

Dans le C++ standard, les énumérations ne sont pas sûres au niveau du type. Elles sont effectivement des entiers.

AnimalFlags ne doit PAS être le type de votre variable. Votre variable doit être int et l'erreur disparaîtra.

Il n'est pas nécessaire de mettre des valeurs hexadécimales comme l'ont suggéré d'autres personnes. Cela ne fait aucune différence.

Les valeurs de l'enum sont de type int par défaut. Ainsi, vous pouvez sûrement les combiner par OU binaire, les assembler et stocker le résultat dans un int.

Le type énumération est un sous-ensemble restreint de int dont la valeur est l'une de ses valeurs énumérées. Par conséquent, lorsque vous créez une nouvelle valeur en dehors de cette plage, vous ne pouvez pas l'affecter sans faire un casting vers une variable de votre type enum.

Vous pouvez également modifier les types de valeurs de l'enum si vous le souhaitez, mais cette question n'a aucun intérêt.

EDIT : Le posteur a dit qu'il était préoccupé par la sécurité des types et qu'il ne voulait pas d'une valeur qui ne devrait pas exister dans le type int.

Mais il serait dangereux de mettre une valeur en dehors de la plage de AnimalFlags dans une variable de type AnimalFlags.

Il existe un moyen sûr de vérifier les valeurs hors limites à l'intérieur du type int...

int iFlags = HasClaws | CanFly;
//InvalidAnimalFlagMaxValue-1 gives you a value of all the bits 
// smaller than itself set to 1
//This check makes sure that no other bits are set.
assert(iFlags & ~(InvalidAnimalFlagMaxValue-1) == 0);

enum AnimalFlags {
    HasClaws = 1,
    CanFly =2,
    EatsFish = 4,
    Endangered = 8,

    // put new enum values above here
    InvalidAnimalFlagMaxValue = 16
};

Ce qui précède ne vous empêche pas de mettre un drapeau invalide d'un enum différent qui a la valeur 1, 2, 4 ou 8.

Si vous voulez une sécurité de type absolue, vous pouvez simplement créer un std::set et y stocker chaque drapeau. Ce n'est pas efficace en termes d'espace, mais c'est sûr au niveau des types et cela vous donne les mêmes possibilités qu'un int bitflag.

Note C++0x : Enums fortement typés

En C++0x, il est enfin possible d'avoir des valeurs d'énumération sans risque pour les types.....

enum class AnimalFlags {
    CanFly = 2,
    HasClaws = 4
};

if(CanFly == 2) { }//Compiling error