Enum string en C++11

J'aime un hack en utilisant le préprocesseur C, qui j'ai vu ici:
http://blogs.msdn.com/b/vcblog/archive/2008/04/30/enums-macros-unicode-and-token-pasting.aspx .

Il utilise le jeton-coller de l'opérateur # .

//This code defines the enumerated values:

#define MY_ENUM(x) x,
enum Fruit_Type {
MY_ENUM(Banana)
MY_ENUM(Apple)
MY_ENUM(Orange)
};
#undef MY_ENUM

//and this code defines an array of string literals for them:

#define MY_ENUM(x) #x,
        const char* const fruit_name[] = {
MY_ENUM(Banana)
MY_ENUM(Apple)
MY_ENUM(Orange)
        };
#undef MY_ENUM

//Finally, here is some client code:

std::cout << fruit_name[Banana] << " is enum #" << Banana << "\n";

//In practice, those three "MY_ENUM" macro calls will be inside an #include file.

Franchement, c'est moche et. mais, en fin de saisie de votre enums exactement une FOIS dans un fichier inclus, ce qui est plus facile à gérer.

BTW, sur MSDN lien de blog (voir ci-dessus) d'un utilisateur fait un commentaire avec un truc qui rend le tout beaucoup plus joli, et évite #comprend:

#define Fruits(FOO) \
FOO(Apple) \
FOO(Banana) \
FOO(Orange)

#define DO_DESCRIPTION(e)  #e,
#define DO_ENUM(e)  e,

char* FruitDescription[] = {
Fruits(DO_DESCRIPTION)
};

enum Fruit_Type {
Fruits(DO_ENUM)
};

//Client code:

std::cout << FruitDescription[Banana] << " is enum #" << Banana << "\n";

(Je viens de remarquer que 0x17de réponse utilise également le jeton-coller de l'opérateur)

Voici un exemple simple d'utilisation des espaces de noms et les structures.
Une classe est créée pour chaque enum élément. Dans cet exemple j'ai choisi int que le type de l'id.

#include <iostream>
using namespace std;

#define ENUMITEM(Id, Name) \
struct Name {\
    static constexpr const int id = Id;\
    static constexpr const char* name = #Name;\
};

namespace Food {
ENUMITEM(1, Banana)
ENUMITEM(2, Apple)
ENUMITEM(3, Orange)
}

int main() {
    cout << Food::Orange::id << ":" << Food::Orange::name << endl;
    return 0;
}

De sortie:

3:Orange

== Mise à jour ==

À l'aide de:

#define STARTENUM() constexpr const int enumStart = __LINE__;
#define ENUMITEM(Name) \
struct Name {\
    static constexpr const int id = __LINE__ - enumStart - 1;\
    static constexpr const char* name = #Name;\
};

et en utilisant une seule fois avant la première utilisation de la ENUMITEM les id ne serait plus nécessaire.

namespace Food {
STARTENUM()
ENUMITEM(Banana)
ENUMITEM(Apple)
ENUMITEM(Orange)
}

La variable enumStart n'est accessible que par le biais de l'espace de noms est donc encore plusieurs énumérations peuvent être utilisés.

Comme mentionné, il n'existe pas de méthode standard pour ce faire. Mais avec un peu de préprocesseur de la magie (similaire à AlejoHausner deuxième contribution) et certains modèles de la magie, il peut être assez élégant.

Inclure ce code une fois:

#include <string>
#include <algorithm>

#define ENUM_VALS( name ) name,
#define ENUM_STRINGS( name ) # name,

/** Template function to return the enum value for a given string
*  Note: assumes enums are all upper or all lowercase,
*        that they are contiguous/default-ordered,
*        and that the first value is the default
*  @tparam ENUM     type of the enum to retrieve
*  @tparam ENUMSIZE number of elements in the enum (implicit; need not be passed in)
*  @param valStr   string version of enum value to convert; may be any capitalization (capitalization may be modified)
*  @param enumStrs array of strings corresponding to enum values, assumed to all be in lower/upper case depending upon
*  enumsUpper
*  @param enumsUpper true if the enum values are in all uppercase, false if in all lowercase (mixed case not supported)
*  @return enum value corresponding to valStr, or the first enum value if not found
*/
template <typename ENUM, size_t ENUMSIZE>
static inline ENUM fromString(std::string &valStr, const char *(&enumStrs)[ENUMSIZE], bool enumsUpper = true) {
    ENUM e = static_cast< ENUM >(0); //by default, first value
    //convert valStr to lower/upper-case
    std::transform(valStr.begin(), valStr.end(), valStr.begin(), enumsUpper ? ::toupper : ::tolower);
    for (size_t i = 0; i< ENUMSIZE; i++) {
        if (valStr == std::string(enumStrs[i])) {
            e = static_cast< ENUM >(i);
            break;
        }
    }
    return e;
}

Puis définissez chaque enum comme suit:

//! Define ColorType enum with array for converting to/from strings
#define ColorTypes(ENUM) \
    ENUM(BLACK) \
    ENUM(RED) \
    ENUM(GREEN) \
    ENUM(BLUE)
enum ColorType {
    ColorTypes(ENUM_VALS)
};
static const char* colorTypeNames[] = {
    ColorTypes(ENUM_STRINGS)
};

Vous n'avez qu'à énumérer les valeurs enum une fois et le code pour définir le il est assez compact et intuitif.

Valeurs devront nécessairement être numérotées dans la méthode par défaut (c'est à dire, 0,1,2,...). Le code de fromString() suppose que les valeurs de l'enum sont en majuscules ou en minuscules (pour la conversion de chaînes de caractères) que la valeur par défaut est la première, mais vous pouvez bien sûr modifier la façon dont ces choses sont traitées.

Ici est de savoir comment vous obtenez la valeur de chaîne:

ColorType c = ColorType::BLUE;   
std::cout << colorTypeNames[c]; //BLUE

Ici est de savoir comment vous définissez l'enum à partir d'une chaîne de valeur:

ColorType c2 = fromString<ColorType>("Green", colorTypeNames); //== ColorType::GREEN