énumération de chaînes dans C++ 11/C++ 14/C++ 17 moderne et futur C++ 20
Contrairement à toutes les autres questions similaires, cette question concerne l'utilisation des nouvelles fonctionnalités C++.
- 2008 cExiste-t-il un moyen simple de convertir une énumération C++ en chaîne?
- 2008 cMoyen facile d'utiliser des variables de types enum en tant que chaîne en C?
- 2008 c ++Comment mapper facilement des enums c ++ sur des chaînes
- 2008 c ++Faire de quelque chose à la fois un identifiant C et une chaîne?
- 2008 c ++Existe-t-il un script simple pour convertir l'énumération C++ en chaîne?
- 2009 c ++Comment utiliser les énumérations comme drapeaux en C++?
- 2011 c ++Comment convertir une variable de type enum en chaîne?
- 2011 c ++Enum to String C++
- 2011 c ++Comment convertir une variable de type enum en chaîne?
- 2012 cComment convertir des noms d'énumération en chaîne en c
- 2013 cStringification d'une enum compilée conditionnellement en C
Après avoir lu de nombreuses réponses, je n'en ai pas encore trouvé:
- Manière élégante en utilisant C++ 11 , C++ 14 ou C++ 17 nouvelles fonctionnalités
- Ou quelque chose de prêt à utiliser dans Boost
- Sinon quelque chose de prévu pour C++ 20
Exemple
Un exemple vaut souvent mieux qu'une longue explication.
Vous pouvez compiler et exécuter cet extrait sur Coliru .
( Un autre exemple précédent est également disponible)
#include <map>
#include <iostream>
struct MyClass
{
enum class MyEnum : char {
AAA = -8,
BBB = '8',
CCC = AAA + BBB
};
};
// Replace magic() by some faster compile-time generated code
// (you're allowed to replace the return type with std::string
// if that's easier for you)
const char* magic (MyClass::MyEnum e)
{
const std::map<MyClass::MyEnum,const char*> MyEnumStrings {
{ MyClass::MyEnum::AAA, "MyClass::MyEnum::AAA" },
{ MyClass::MyEnum::BBB, "MyClass::MyEnum::BBB" },
{ MyClass::MyEnum::CCC, "MyClass::MyEnum::CCC" }
};
auto it = MyEnumStrings.find(e);
return it == MyEnumStrings.end() ? "Out of range" : it->second;
}
int main()
{
std::cout << magic(MyClass::MyEnum::AAA) <<'\n';
std::cout << magic(MyClass::MyEnum::BBB) <<'\n';
std::cout << magic(MyClass::MyEnum::CCC) <<'\n';
}
Contraintes
- S'il vous plaît pas de duplication précieuse de d'autres réponses ou lien de base .
- Évitez les réponses basées sur des macros macro ou essayez de réduire au minimum le temps système
#defineau minimum. - S'il vous plaît pas de manuel
enum->stringmapping.
Bon d'avoir
- Prend en charge les valeurs
enumà partir d'un nombre différent de zéro - Prend en charge les valeurs
enumnégatives - Prise en charge des valeurs
enumfragmentées - Support
class enum(C++ 11) - Supportez
class enum : <type>avec n'importe quel<type>autorisé (C++ 11) - Conversions en une chaîne à la compilation (pas à l'exécution),
ou au moins une exécution rapide au moment de l'exécution (par exemple,std::mapn'est pas une bonne idée ...) constexpr(C++ 11, relâché en C++ 14)noexcept(C++ 11)- extrait C++ 14/C++ 17 convivial
- C++ Etat de la technique
Une idée possible pourrait être d'utiliser les capacités du compilateur C++ pour générer du code C++ au moment de la compilation en utilisant des astuces de méta-programmation basées sur les fonctions variadic template class et constexpr ...
Ceci est similaire à Yuri Finkelstein; mais ne nécessite pas de boost. J'utilise une carte pour que vous puissiez attribuer n'importe quelle valeur aux enums, à n'importe quel ordre.
Déclaration de classe d'énumération en tant que:
DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);
Le code suivant créera automatiquement la classe enum et la surcharge:
- '+' '+ =' pour std :: string
- '<<' pour les flux
- '~' juste pour convertir en chaîne (tout opérateur unaire fera l'affaire, mais personnellement, je n'aime pas ça pour plus de clarté)
- '*' pour obtenir le nombre d'enums
Aucun boost requis, toutes les fonctions requises sont fournies.
Code:
#include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#define STRING_REMOVE_CHAR(str, ch) str.erase(std::remove(str.begin(), str.end(), ch), str.end())
std::vector<std::string> splitString(std::string str, char sep = ',') {
std::vector<std::string> vecString;
std::string item;
std::stringstream stringStream(str);
while (std::getline(stringStream, item, sep))
{
vecString.Push_back(item);
}
return vecString;
}
#define DECLARE_ENUM_WITH_TYPE(E, T, ...) \
enum class E : T \
{ \
__VA_ARGS__ \
}; \
std::map<T, std::string> E##MapName(generateEnumMap<T>(#__VA_ARGS__)); \
std::ostream &operator<<(std::ostream &os, E enumTmp) \
{ \
os << E##MapName[static_cast<T>(enumTmp)]; \
return os; \
} \
size_t operator*(E enumTmp) { (void) enumTmp; return E##MapName.size(); } \
std::string operator~(E enumTmp) { return E##MapName[static_cast<T>(enumTmp)]; } \
std::string operator+(std::string &&str, E enumTmp) { return str + E##MapName[static_cast<T>(enumTmp)]; } \
std::string operator+(E enumTmp, std::string &&str) { return E##MapName[static_cast<T>(enumTmp)] + str; } \
std::string &operator+=(std::string &str, E enumTmp) \
{ \
str += E##MapName[static_cast<T>(enumTmp)]; \
return str; \
} \
E operator++(E &enumTmp) \
{ \
auto iter = E##MapName.find(static_cast<T>(enumTmp)); \
if (iter == E##MapName.end() || std::next(iter) == E##MapName.end()) \
iter = E##MapName.begin(); \
else \
{ \
++iter; \
} \
enumTmp = static_cast<E>(iter->first); \
return enumTmp; \
} \
bool valid##E(T value) { return (E##MapName.find(value) != E##MapName.end()); }
#define DECLARE_ENUM(E, ...) DECLARE_ENUM_WITH_TYPE(E, int32_t, __VA_ARGS__)
template <typename T>
std::map<T, std::string> generateEnumMap(std::string strMap)
{
STRING_REMOVE_CHAR(strMap, ' ');
STRING_REMOVE_CHAR(strMap, '(');
std::vector<std::string> enumTokens(splitString(strMap));
std::map<T, std::string> retMap;
T inxMap;
inxMap = 0;
for (auto iter = enumTokens.begin(); iter != enumTokens.end(); ++iter)
{
// Token: [EnumName | EnumName=EnumValue]
std::string enumName;
T enumValue;
if (iter->find('=') == std::string::npos)
{
enumName = *iter;
}
else
{
std::vector<std::string> enumNameValue(splitString(*iter, '='));
enumName = enumNameValue[0];
//inxMap = static_cast<T>(enumNameValue[1]);
if (std::is_unsigned<T>::value)
{
inxMap = static_cast<T>(std::stoull(enumNameValue[1], 0, 0));
}
else
{
inxMap = static_cast<T>(std::stoll(enumNameValue[1], 0, 0));
}
}
retMap[inxMap++] = enumName;
}
return retMap;
}
Exemple:
DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);
int main(void) {
TestEnumClass first, second;
first = TestEnumClass::FOUR;
second = TestEnumClass::TWO;
std::cout << first << "(" << static_cast<uint32_t>(first) << ")" << std::endl; // FOUR(4)
std::string strOne;
strOne = ~first;
std::cout << strOne << std::endl; // FOUR
std::string strTwo;
strTwo = ("Enum-" + second) + (TestEnumClass::THREE + "-test");
std::cout << strTwo << std::endl; // Enum-TWOTHREE-test
std::string strThree("TestEnumClass: ");
strThree += second;
std::cout << strThree << std::endl; // TestEnumClass: TWO
std::cout << "Enum count=" << *first << std::endl;
}
You can run the code here
(L'approche de la bibliothèque better_enums )
Il existe un moyen de faire enum à string dans C++ actuel qui ressemble à ceci:
ENUM(Channel, char, Red = 1, Green, Blue)
// "Same as":
// enum class Channel : char { Red = 1, Green, Blue };
Usage:
Channel c = Channel::_from_string("Green"); // Channel::Green (2)
c._to_string(); // string "Green"
for (Channel c : Channel::_values())
std::cout << c << std::endl;
// And so on...
Toutes les opérations peuvent être effectuées constexpr. Vous pouvez également implémenter la proposition de réflexion C++ 17 mentionnée dans la réponse de @ecatmur.
- Il n'y a qu'une seule macro. Je pense que c'est le minimum possible, car la conversion en chaîne du préprocesseur (
#) est le seul moyen de convertir un jeton en chaîne en C++ actuel. - La macro est assez discrète - les déclarations de constante, y compris les initialiseurs, sont collées dans une déclaration enum intégrée. Cela signifie qu'ils ont la même syntaxe et la même signification que dans une énumération intégrée.
- La répétition est éliminée.
- L'implémentation est la plus naturelle et utile au moins dans C++ 11, en raison de
constexpr. On peut aussi le faire fonctionner avec C++ 98 +__VA_ARGS__. C'est définitivement le C++ moderne.
La définition de la macro est quelque peu impliquée, alors je réponds de plusieurs manières.
- Le gros de cette réponse est une implémentation qui, à mon avis, convient aux contraintes d’espace sur StackOverflow.
- Il existe également un article de CodeProject décrivant les bases de la mise en œuvre dans un didacticiel détaillé. [Dois-je le déplacer ici? Je pense que c'est trop pour une SO réponse].
- Il existe une bibliothèque complète "Better Enums" qui implémente la macro dans un fichier d'en-tête unique. Il implémente également (Requêtes de propriété de type N4428) , la révision en cours de la proposition de réflexion C++ 17 N4113. Ainsi, au moins pour les énumérations déclarées par cette macro, vous pouvez maintenant avoir la réflexion d’énumération proposée par C++ 17, en C++ 11/C++ 14.
Il est facile d'étendre cette réponse aux fonctionnalités de la bibliothèque - rien "d'important" n'est laissé ici. C’est cependant assez fastidieux et la portabilité du compilateur est problématique.
Disclaimer: Je suis l'auteur de l'article CodeProject et de la bibliothèque.
Vous pouvez essayer le code dans cette réponse _, la bibliothèque et l'implémentation de N4428 en ligne dans Wandbox. La documentation de la bibliothèque contient également un présentation de son utilisation en tant que N4428 , qui explique la partie énumérations de cette proposition.
Explication
Le code ci-dessous implémente des conversions entre enums et chaînes. Cependant, il peut être étendu à d'autres tâches, telles que l'itération. Cette réponse enveloppe une énumération dans un struct. Vous pouvez également générer un trait struct à côté d'une énumération.
La stratégie consiste à générer quelque chose comme ceci:
struct Channel {
enum _enum : char { __VA_ARGS__ };
constexpr static const Channel _values[] = { __VA_ARGS__ };
constexpr static const char * const _names[] = { #__VA_ARGS__ };
static const char* _to_string(Channel v) { /* easy */ }
constexpr static Channel _from_string(const char *s) { /* easy */ }
};
Les problèmes sont:
- Nous nous retrouverons avec quelque chose comme
{Red = 1, Green, Blue}comme initialiseur pour le tableau de valeurs. Ceci n'est pas valide C++, carRedn'est pas une expression assignable. Ceci est résolu en convertissant chaque constante en un typeTayant un opérateur d'affectation, mais supprimant l'affectation:{(T)Red = 1, (T)Green, (T)Blue}. - De même, nous allons nous retrouver avec
{"Red = 1", "Green", "Blue"}comme initialiseur du tableau de noms. Nous devrons couper le" = 1". Je ne suis pas au courant d'une excellente façon de faire cela au moment de la compilation, nous allons donc reporter cela à l'exécution. En conséquence,_to_stringne sera pasconstexpr, mais_from_stringpourra quand même êtreconstexpr, car nous pouvons traiter les espaces et les signes équivalents comme des terminateurs lors de la comparaison avec des chaînes non limitées. - Les deux éléments ci-dessus nécessitent une macro de "mappage" pouvant appliquer une autre macro à chaque élément de
__VA_ARGS__. C'est assez standard. Cette réponse comprend une version simple pouvant gérer jusqu'à 8 éléments. - Si la macro doit être réellement autonome, elle ne doit déclarer aucune donnée statique nécessitant une définition distincte. En pratique, cela signifie que les baies nécessitent un traitement spécial. Il existe deux solutions possibles: les tableaux
constexpr(ou simplementconst) au niveau de l'espace de noms ou les tableaux classiques dans des fonctions inline statiques non -constexpr. Le code dans cette réponse est pour C++ 11 et adopte l'approche précédente. L'article CodeProject est pour C++ 98 et prend ce dernier.
Code
#include <cstddef> // For size_t.
#include <cstring> // For strcspn, strncpy.
#include <stdexcept> // For runtime_error.
// A "typical" mapping macro. MAP(macro, a, b, c, ...) expands to
// macro(a) macro(b) macro(c) ...
// The helper macro COUNT(a, b, c, ...) expands to the number of
// arguments, and IDENTITY(x) is needed to control the order of
// expansion of __VA_ARGS__ on Visual C++ compilers.
#define MAP(macro, ...) \
IDENTITY( \
APPLY(CHOOSE_MAP_START, COUNT(__VA_ARGS__)) \
(macro, __VA_ARGS__))
#define CHOOSE_MAP_START(count) MAP ## count
#define APPLY(macro, ...) IDENTITY(macro(__VA_ARGS__))
#define IDENTITY(x) x
#define MAP1(m, x) m(x)
#define MAP2(m, x, ...) m(x) IDENTITY(MAP1(m, __VA_ARGS__))
#define MAP3(m, x, ...) m(x) IDENTITY(MAP2(m, __VA_ARGS__))
#define MAP4(m, x, ...) m(x) IDENTITY(MAP3(m, __VA_ARGS__))
#define MAP5(m, x, ...) m(x) IDENTITY(MAP4(m, __VA_ARGS__))
#define MAP6(m, x, ...) m(x) IDENTITY(MAP5(m, __VA_ARGS__))
#define MAP7(m, x, ...) m(x) IDENTITY(MAP6(m, __VA_ARGS__))
#define MAP8(m, x, ...) m(x) IDENTITY(MAP7(m, __VA_ARGS__))
#define EVALUATE_COUNT(_1, _2, _3, _4, _5, _6, _7, _8, count, ...) \
count
#define COUNT(...) \
IDENTITY(EVALUATE_COUNT(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1))
// The type "T" mentioned above that drops assignment operations.
template <typename U>
struct ignore_assign {
constexpr explicit ignore_assign(U value) : _value(value) { }
constexpr operator U() const { return _value; }
constexpr const ignore_assign& operator =(int dummy) const
{ return *this; }
U _value;
};
// Prepends "(ignore_assign<_underlying>)" to each argument.
#define IGNORE_ASSIGN_SINGLE(e) (ignore_assign<_underlying>)e,
#define IGNORE_ASSIGN(...) \
IDENTITY(MAP(IGNORE_ASSIGN_SINGLE, __VA_ARGS__))
// Stringizes each argument.
#define STRINGIZE_SINGLE(e) #e,
#define STRINGIZE(...) IDENTITY(MAP(STRINGIZE_SINGLE, __VA_ARGS__))
// Some helpers needed for _from_string.
constexpr const char terminators[] = " =\t\r\n";
// The size of terminators includes the implicit '\0'.
constexpr bool is_terminator(char c, size_t index = 0)
{
return
index >= sizeof(terminators) ? false :
c == terminators[index] ? true :
is_terminator(c, index + 1);
}
constexpr bool matches_untrimmed(const char *untrimmed, const char *s,
size_t index = 0)
{
return
is_terminator(untrimmed[index]) ? s[index] == '\0' :
s[index] != untrimmed[index] ? false :
matches_untrimmed(untrimmed, s, index + 1);
}
// The macro proper.
//
// There are several "simplifications" in this implementation, for the
// sake of brevity. First, we have only one viable option for declaring
// constexpr arrays: at namespace scope. This probably should be done
// two namespaces deep: one namespace that is likely to be unique for
// our little enum "library", then inside it a namespace whose name is
// based on the name of the enum to avoid collisions with other enums.
// I am using only one level of nesting.
//
// Declaring constexpr arrays inside the struct is not viable because
// they will need out-of-line definitions, which will result in
// duplicate symbols when linking. This can be solved with weak
// symbols, but that is compiler- and system-specific. It is not
// possible to declare constexpr arrays as static variables in
// constexpr functions due to the restrictions on such functions.
//
// Note that this prevents the use of this macro anywhere except at
// namespace scope. Ironically, the C++98 version of this, which can
// declare static arrays inside static member functions, is actually
// more flexible in this regard. It is shown in the CodeProject
// article.
//
// Second, for compilation performance reasons, it is best to separate
// the macro into a "parametric" portion, and the portion that depends
// on knowing __VA_ARGS__, and factor the former out into a template.
//
// Third, this code uses a default parameter in _from_string that may
// be better not exposed in the public interface.
#define ENUM(EnumName, Underlying, ...) \
namespace data_ ## EnumName { \
using _underlying = Underlying; \
enum { __VA_ARGS__ }; \
\
constexpr const size_t _size = \
IDENTITY(COUNT(__VA_ARGS__)); \
\
constexpr const _underlying _values[] = \
{ IDENTITY(IGNORE_ASSIGN(__VA_ARGS__)) }; \
\
constexpr const char * const _raw_names[] = \
{ IDENTITY(STRINGIZE(__VA_ARGS__)) }; \
} \
\
struct EnumName { \
using _underlying = Underlying; \
enum _enum : _underlying { __VA_ARGS__ }; \
\
const char * _to_string() const \
{ \
for (size_t index = 0; index < data_ ## EnumName::_size; \
++index) { \
\
if (data_ ## EnumName::_values[index] == _value) \
return _trimmed_names()[index]; \
} \
\
throw std::runtime_error("invalid value"); \
} \
\
constexpr static EnumName _from_string(const char *s, \
size_t index = 0) \
{ \
return \
index >= data_ ## EnumName::_size ? \
throw std::runtime_error("invalid identifier") : \
matches_untrimmed( \
data_ ## EnumName::_raw_names[index], s) ? \
(EnumName)(_enum)data_ ## EnumName::_values[ \
index] : \
_from_string(s, index + 1); \
} \
\
EnumName() = delete; \
constexpr EnumName(_enum value) : _value(value) { } \
constexpr operator _enum() const { return (_enum)_value; } \
\
private: \
_underlying _value; \
\
static const char * const * _trimmed_names() \
{ \
static char *the_names[data_ ## EnumName::_size]; \
static bool initialized = false; \
\
if (!initialized) { \
for (size_t index = 0; index < data_ ## EnumName::_size; \
++index) { \
\
size_t length = \
std::strcspn(data_ ## EnumName::_raw_names[index],\
terminators); \
\
the_names[index] = new char[length + 1]; \
\
std::strncpy(the_names[index], \
data_ ## EnumName::_raw_names[index], \
length); \
the_names[index][length] = '\0'; \
} \
\
initialized = true; \
} \
\
return the_names; \
} \
};
et
// The code above was a "header file". This is a program that uses it.
#include <iostream>
#include "the_file_above.h"
ENUM(Channel, char, Red = 1, Green, Blue)
constexpr Channel channel = Channel::_from_string("Red");
int main()
{
std::cout << channel._to_string() << std::endl;
switch (channel) {
case Channel::Red: return 0;
case Channel::Green: return 1;
case Channel::Blue: return 2;
}
}
static_assert(sizeof(Channel) == sizeof(char), "");
Le programme ci-dessus affiche Red, comme vous vous en doutez. Il existe un certain degré de sécurité de type, car vous ne pouvez pas créer une énumération sans l'initialiser et la suppression de l'un des cas de switch entraînera un avertissement du compilateur (selon votre compilateur et vos indicateurs). Notez également que "Red" a été converti en une énumération lors de la compilation.
Pour C++ 17 C++ 20, vous serez intéressé par les travaux du groupe d’étude sur la réflexion (SG7). Il existe une série d'articles parallèles couvrant libellé ( P0194 ) et justification, conception et évolution ( P0385 ). (Liens résolus vers le dernier document de chaque série.)
A partir de P0194r2 (2016-10-15), la syntaxe utiliserait le mot clé reflexpr proposé:
meta::get_base_name_v<
meta::get_element_m<
meta::get_enumerators_m<reflexpr(MyEnum)>,
0>
>
Par exemple (adapté de branche de clang de Matus Choclik ):
#include <reflexpr>
#include <iostream>
enum MyEnum { AAA = 1, BBB, CCC = 99 };
int main()
{
auto name_of_MyEnum_0 =
std::meta::get_base_name_v<
std::meta::get_element_m<
std::meta::get_enumerators_m<reflexpr(MyEnum)>,
0>
>;
// prints "AAA"
std::cout << name_of_MyEnum_0 << std::endl;
}
La réflexion statique n'a pas réussi à entrer dans C++ 17 (mais plutôt dans le projet probablement final présenté à la réunion sur les normes de novembre 2016 à Issaquah), mais il est certain que cela se fera dans C++ 20; de rapport de voyage de Herb Sutter }:
En particulier, le groupe d’étude Reflection a examiné la dernière proposition de réflexion statique fusionnée et s’est déclaré prêt à intégrer les principaux groupes d’Evolution lors de notre prochaine réunion afin de commencer à examiner la proposition de réflexion statique unifiée pour une TS ou pour la prochaine norme.
En 2011, j'ai passé un week-end à peaufiner une solution basée sur une macro et je n'ai finalement jamais utilisé cette solution.
Ma procédure actuelle consiste à démarrer Vim, à copier les énumérateurs dans un corps de commutateur vide, à démarrer une nouvelle macro, à transformer le premier énumérateur en une instruction case, déplace le curseur au début de la ligne suivante, arrête la macro et générer les instructions case restantes en exécutant la macro sur les autres énumérateurs.
Les macros Vim sont plus amusantes que les macros C++.
Exemple concret:
enum class EtherType : uint16_t
{
ARP = 0x0806,
IPv4 = 0x0800,
VLAN = 0x8100,
IPv6 = 0x86DD
};
Je vais créer ceci:
std::ostream& operator<< (std::ostream& os, EtherType ethertype)
{
switch (ethertype)
{
case EtherType::ARP : return os << "ARP" ;
case EtherType::IPv4: return os << "IPv4";
case EtherType::VLAN: return os << "VLAN";
case EtherType::IPv6: return os << "IPv6";
// omit default case to trigger compiler warning for missing cases
};
return os << static_cast<std::uint16_t>(ethertype);
}
Et c'est comme ça que je me débrouille.
Le support natif pour la énumération enum serait beaucoup mieux. Je suis très intéressé de voir les résultats du groupe de travail de réflexion en C++ 17.
Une autre façon de le faire a été publiée par @sehe dans les commentaires .
Je ne sais pas si cela vous plaira ou non, je ne suis pas assez satisfait de cette solution, mais il s'agit d'une approche conviviale pour C++ 14 car elle utilise des variables de modèle et abuse de la spécialisation de modèle:
enum class MyEnum : std::uint_fast8_t {
AAA,
BBB,
CCC,
};
template<MyEnum> const char MyEnumName[] = "Invalid MyEnum value";
template<> const char MyEnumName<MyEnum::AAA>[] = "AAA";
template<> const char MyEnumName<MyEnum::BBB>[] = "BBB";
template<> const char MyEnumName<MyEnum::CCC>[] = "CCC";
int main()
{
// Prints "AAA"
std::cout << MyEnumName<MyEnum::AAA> << '\n';
// Prints "Invalid MyEnum value"
std::cout << MyEnumName<static_cast<MyEnum>(0x12345678)> << '\n';
// Well... in fact it prints "Invalid MyEnum value" for any value
// different of MyEnum::AAA, MyEnum::BBB or MyEnum::CCC.
return 0;
}
Le pire dans cette approche est qu’il est difficile de maintenir, mais c’est également difficile de maintenir certaines approches similaires, n’est-ce pas?
Bons points à propos de cette approche:
- Utilisation de variables tempates (fonctionnalité C++ 14)
- Avec la spécialisation des modèles, nous pouvons "détecter" lorsqu'une valeur non valide est utilisée (mais je ne suis pas sûr que cela puisse être utile du tout).
- Ça a l'air chouette.
- La recherche de nom est faite à la compilation.
Modifier
Misterious ser673679 vous avez raison; L'approche de modèle de variable C++ 14 ne gère pas le cas d'exécution, c'est de ma faute de l'oublier :(
Mais nous pouvons toujours utiliser certaines fonctionnalités modernes du C++, des modèles variés et une supercherie de modèles variadiques pour obtenir une traduction d'exécution de valeur enum en chaîne ... elle est aussi gênante que les autres, mais mérite néanmoins d'être mentionnée.
Commençons par utiliser un alias de modèle pour raccourcir l'accès à une mappe énumération-chaîne:
// enum_map contains pairs of enum value and value string for each enum
// this shortcut allows us to use enum_map<whatever>.
template <typename ENUM>
using enum_map = std::map<ENUM, const std::string>;
// This variable template will create a map for each enum type which is
// instantiated with.
template <typename ENUM>
enum_map<ENUM> enum_values{};
Ensuite, la supercherie de modèles variadiques:
template <typename ENUM>
void initialize() {}
template <typename ENUM, typename ... args>
void initialize(const ENUM value, const char *name, args ... tail)
{
enum_values<ENUM>.emplace(value, name);
initialize<ENUM>(tail ...);
}
Le "meilleure astuce" est ici l'utilisation d'un modèle de variable pour la carte qui contient les valeurs et les noms de chaque entrée enum; cette carte sera la même dans chaque unité de traduction et aura le même nom partout, donc c'est assez simple et net, si nous appelons la fonction initialize comme ceci:
initialize
(
MyEnum::AAA, "AAA",
MyEnum::BBB, "BBB",
MyEnum::CCC, "CCC"
);
Nous assignons des noms à chaque entrée MyEnum et pouvons être utilisés au moment de l'exécution:
std::cout << enum_values<MyEnum>[MyEnum::AAA] << '\n';
Mais peut être amélioré avec SFINAE et l'opérateur de surcharge <<:
template<typename ENUM, class = typename std::enable_if<std::is_enum<ENUM>::value>::type>
std::ostream &operator <<(std::ostream &o, const ENUM value)
{
static const std::string Unknown{std::string{typeid(ENUM).name()} + " unknown value"};
auto found = enum_values<ENUM>.find(value);
return o << (found == enum_values<ENUM>.end() ? Unknown : found->second);
}
Avec le operator << correct, nous pouvons maintenant utiliser l'énumération de cette façon:
std::cout << MyEnum::AAA << '\n';
Cela est également gênant à maintenir et peut être amélioré, mais espérons que vous aurez l’idée.
Si votre enum ressemble à
enum MyEnum
{
AAA = -8,
BBB = '8',
CCC = AAA + BBB
};
Vous pouvez déplacer le contenu de la enum vers un nouveau fichier:
AAA = -8,
BBB = '8',
CCC = AAA + BBB
Et puis les valeurs peuvent être entourées d'une macro:
// default definition
#ifned ITEM(X,Y)
#define ITEM(X,Y)
#endif
// Items list
ITEM(AAA,-8)
ITEM(BBB,'8')
ITEM(CCC,AAA+BBB)
// clean up
#undef ITEM
La prochaine étape peut être d’inclure à nouveau les éléments de la enum:
enum MyEnum
{
#define ITEM(X,Y) X=Y,
#include "enum_definition_file"
};
Et enfin, vous pouvez générer des fonctions utilitaires à propos de cette enum:
std::string ToString(MyEnum value)
{
switch( value )
{
#define ITEM(X,Y) case X: return #X;
#include "enum_definition_file"
}
return "";
}
MyEnum FromString(std::string const& value)
{
static std::map<std::string,MyEnum> converter
{
#define ITEM(X,Y) { #X, X },
#include "enum_definition_file"
};
auto it = converter.find(value);
if( it != converter.end() )
return it->second;
else
throw std::runtime_error("Value is missing");
}
La solution peut être appliquée aux anciennes normes C++ et n'utilise pas les éléments C++ modernes, mais elle peut être utilisée pour générer beaucoup de code sans trop de travail et de maintenance.
J'ai eu le même problème il y a quelques jours. Je ne pouvais trouver aucune solution C++ sans une magie de macro étrange, alors j'ai décidé d'écrire un générateur de code CMake pour générer des instructions de cas de commutation simples.
Usage:
enum2str_generate(
PATH <path to place the files in>
CLASS_NAME <name of the class (also prefix for the files)>
FUNC_NAME <name of the (static) member function>
NAMESPACE <the class will be inside this namespace>
INCLUDES <LIST of files where the enums are defined>
ENUMS <LIST of enums to process>
BLACKLIST <LIST of constants to ignore>
USE_CONSTEXPR <whether to use constexpr or not (default: off)>
USE_C_STRINGS <whether to use c strings instead of std::string or not (default: off)>
)
La fonction recherche les fichiers d'inclusion dans le système de fichiers (utilise les répertoires d'inclusion fournis avec la commande include_directories), les lit et effectue des regex pour générer la classe et la ou les fonctions.
REMARQUE: constexpr implique inline en C++. L'utilisation de l'option USE_CONSTEXPR générera donc une classe d'en-tête uniquement!
Exemple:
./includes/a.h:
enum AAA : char { A1, A2 };
typedef enum {
VAL1 = 0,
VAL2 = 1,
VAL3 = 2,
VAL_FIRST = VAL1, // Ignored
VAL_LAST = VAL3, // Ignored
VAL_DUPLICATE = 1, // Ignored
VAL_STRANGE = VAL2 + 1 // Must be blacklisted
} BBB;
./CMakeLists.txt:
include_directories( ${PROJECT_SOURCE_DIR}/includes ...)
enum2str_generate(
PATH "${PROJECT_SOURCE_DIR}"
CLASS_NAME "enum2Str"
NAMESPACE "abc"
FUNC_NAME "toStr"
INCLUDES "a.h" # WITHOUT directory
ENUMS "AAA" "BBB"
BLACKLIST "VAL_STRANGE")
Génère:
./enum2Str.hpp:
/*!
* \file enum2Str.hpp
* \warning This is an automatically generated file!
*/
#ifndef ENUM2STR_HPP
#define ENUM2STR_HPP
#include <string>
#include <a.h>
namespace abc {
class enum2Str {
public:
static std::string toStr( AAA _var ) noexcept;
static std::string toStr( BBB _var ) noexcept;
};
}
#endif // ENUM2STR_HPP
./enum2Str.cpp:
/*!
* \file enum2Str.cpp
* \warning This is an automatically generated file!
*/
#include "enum2Str.hpp"
namespace abc {
/*!
* \brief Converts the enum AAA to a std::string
* \param _var The enum value to convert
* \returns _var converted to a std::string
*/
std::string enum2Str::toStr( AAA _var ) noexcept {
switch ( _var ) {
case A1: return "A1";
case A2: return "A2";
default: return "<UNKNOWN>";
}
}
/*!
* \brief Converts the enum BBB to a std::string
* \param _var The enum value to convert
* \returns _var converted to a std::string
*/
std::string enum2Str::toStr( BBB _var ) noexcept {
switch ( _var ) {
case VAL1: return "VAL1";
case VAL2: return "VAL2";
case VAL3: return "VAL3";
default: return "<UNKNOWN>";
}
}
}
Mettre à jour:
Le script prend désormais également en charge les énumérations étendues (enum class | struct) et Je l'ai déplacé vers un dépôt séparé avec d'autres scripts que j'utilise souvent: https://github.com/mensinda/cmakeBuildTools
Il suffit de générer vos enums. Écrire un générateur à cette fin demande environ cinq minutes de travail.
Code générateur en Java et en python, très facile à porter dans n’importe quel langage, y compris le C++.
Aussi super facile à étendre par n'importe quelle fonctionnalité que vous voulez.
exemple d'entrée:
First = 5
Second
Third = 7
Fourth
Fifth=11
en-tête généré:
#include <iosfwd>
enum class Hallo
{
First = 5,
Second = 6,
Third = 7,
Fourth = 8,
Fifth = 11
};
std::ostream & operator << (std::ostream &, const Hallo&);
fichier cpp généré
#include <ostream>
#include "Hallo.h"
std::ostream & operator << (std::ostream &out, const Hallo&value)
{
switch(value)
{
case Hallo::First:
out << "First";
break;
case Hallo::Second:
out << "Second";
break;
case Hallo::Third:
out << "Third";
break;
case Hallo::Fourth:
out << "Fourth";
break;
case Hallo::Fifth:
out << "Fifth";
break;
default:
out << "<unknown>";
}
return out;
}
Et le générateur, sous une forme très laconique, servant de modèle pour le portage et l’extension. Cet exemple de code essaie vraiment d'éviter d'écraser des fichiers mais de les utiliser à vos risques et périls.
package cppgen;
import Java.io.BufferedReader;
import Java.io.File;
import Java.io.FileInputStream;
import Java.io.FileOutputStream;
import Java.io.InputStreamReader;
import Java.io.OutputStreamWriter;
import Java.io.PrintWriter;
import Java.nio.charset.Charset;
import Java.util.LinkedHashMap;
import Java.util.Map;
import Java.util.Map.Entry;
import Java.util.regex.Matcher;
import Java.util.regex.Pattern;
public class EnumGenerator
{
static void fail(String message)
{
System.err.println(message);
System.exit(1);
}
static void run(String[] args)
throws Exception
{
Pattern pattern = Pattern.compile("\\s*(\\w+)\\s*(?:=\\s*(\\d+))?\\s*", Pattern.UNICODE_CHARACTER_CLASS);
Charset charset = Charset.forName("UTF8");
String tab = " ";
if (args.length != 3)
{
fail("Required arguments: <enum name> <input file> <output dir>");
}
String enumName = args[0];
File inputFile = new File(args[1]);
if (inputFile.isFile() == false)
{
fail("Not a file: [" + inputFile.getCanonicalPath() + "]");
}
File outputDir = new File(args[2]);
if (outputDir.isDirectory() == false)
{
fail("Not a directory: [" + outputDir.getCanonicalPath() + "]");
}
File headerFile = new File(outputDir, enumName + ".h");
File codeFile = new File(outputDir, enumName + ".cpp");
for (File file : new File[] { headerFile, codeFile })
{
if (file.exists())
{
fail("Will not overwrite file [" + file.getCanonicalPath() + "]");
}
}
int nextValue = 0;
Map<String, Integer> fields = new LinkedHashMap<>();
try
(
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile), charset));
)
{
while (true)
{
String line = reader.readLine();
if (line == null)
{
break;
}
if (line.trim().length() == 0)
{
continue;
}
Matcher matcher = pattern.matcher(line);
if (matcher.matches() == false)
{
fail("Syntax error: [" + line + "]");
}
String fieldName = matcher.group(1);
if (fields.containsKey(fieldName))
{
fail("Double fiend name: " + fieldName);
}
String valueString = matcher.group(2);
if (valueString != null)
{
int value = Integer.parseInt(valueString);
if (value < nextValue)
{
fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName);
}
nextValue = value;
}
fields.put(fieldName, nextValue);
++nextValue;
}
}
try
(
PrintWriter headerWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(headerFile), charset));
PrintWriter codeWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(codeFile), charset));
)
{
headerWriter.println();
headerWriter.println("#include <iosfwd>");
headerWriter.println();
headerWriter.println("enum class " + enumName);
headerWriter.println('{');
boolean first = true;
for (Entry<String, Integer> entry : fields.entrySet())
{
if (first == false)
{
headerWriter.println(",");
}
headerWriter.print(tab + entry.getKey() + " = " + entry.getValue());
first = false;
}
if (first == false)
{
headerWriter.println();
}
headerWriter.println("};");
headerWriter.println();
headerWriter.println("std::ostream & operator << (std::ostream &, const " + enumName + "&);");
headerWriter.println();
codeWriter.println();
codeWriter.println("#include <ostream>");
codeWriter.println();
codeWriter.println("#include \"" + enumName + ".h\"");
codeWriter.println();
codeWriter.println("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)");
codeWriter.println('{');
codeWriter.println(tab + "switch(value)");
codeWriter.println(tab + '{');
first = true;
for (Entry<String, Integer> entry : fields.entrySet())
{
codeWriter.println(tab + "case " + enumName + "::" + entry.getKey() + ':');
codeWriter.println(tab + tab + "out << \"" + entry.getKey() + "\";");
codeWriter.println(tab + tab + "break;");
first = false;
}
codeWriter.println(tab + "default:");
codeWriter.println(tab + tab + "out << \"<unknown>\";");
codeWriter.println(tab + '}');
codeWriter.println();
codeWriter.println(tab + "return out;");
codeWriter.println('}');
codeWriter.println();
}
}
public static void main(String[] args)
{
try
{
run(args);
}
catch(Exception exc)
{
exc.printStackTrace();
System.exit(1);
}
}
}
Et un portage vers Python 3.5 car suffisamment différent pour être potentiellement utile
import re
import collections
import sys
import io
import os
def fail(*args):
print(*args)
exit(1)
pattern = re.compile(r'\s*(\w+)\s*(?:=\s*(\d+))?\s*')
tab = " "
if len(sys.argv) != 4:
n=0
for arg in sys.argv:
print("arg", n, ":", arg, " / ", sys.argv[n])
n += 1
fail("Required arguments: <enum name> <input file> <output dir>")
enumName = sys.argv[1]
inputFile = sys.argv[2]
if not os.path.isfile(inputFile):
fail("Not a file: [" + os.path.abspath(inputFile) + "]")
outputDir = sys.argv[3]
if not os.path.isdir(outputDir):
fail("Not a directory: [" + os.path.abspath(outputDir) + "]")
headerFile = os.path.join(outputDir, enumName + ".h")
codeFile = os.path.join(outputDir, enumName + ".cpp")
for file in [ headerFile, codeFile ]:
if os.path.exists(file):
fail("Will not overwrite file [" + os.path.abspath(file) + "]")
nextValue = 0
fields = collections.OrderedDict()
for line in open(inputFile, 'r'):
line = line.strip()
if len(line) == 0:
continue
match = pattern.match(line)
if match == None:
fail("Syntax error: [" + line + "]")
fieldName = match.group(1)
if fieldName in fields:
fail("Double field name: " + fieldName)
valueString = match.group(2)
if valueString != None:
value = int(valueString)
if value < nextValue:
fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName)
nextValue = value
fields[fieldName] = nextValue
nextValue += 1
headerWriter = open(headerFile, 'w')
codeWriter = open(codeFile, 'w')
try:
headerWriter.write("\n")
headerWriter.write("#include <iosfwd>\n")
headerWriter.write("\n")
headerWriter.write("enum class " + enumName + "\n")
headerWriter.write("{\n")
first = True
for fieldName, fieldValue in fields.items():
if not first:
headerWriter.write(",\n")
headerWriter.write(tab + fieldName + " = " + str(fieldValue))
first = False
if not first:
headerWriter.write("\n")
headerWriter.write("};\n")
headerWriter.write("\n")
headerWriter.write("std::ostream & operator << (std::ostream &, const " + enumName + "&);\n")
headerWriter.write("\n")
codeWriter.write("\n")
codeWriter.write("#include <ostream>\n")
codeWriter.write("\n")
codeWriter.write("#include \"" + enumName + ".h\"\n")
codeWriter.write("\n")
codeWriter.write("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)\n")
codeWriter.write("{\n")
codeWriter.write(tab + "switch(value)\n")
codeWriter.write(tab + "{\n")
for fieldName in fields.keys():
codeWriter.write(tab + "case " + enumName + "::" + fieldName + ":\n")
codeWriter.write(tab + tab + "out << \"" + fieldName + "\";\n")
codeWriter.write(tab + tab + "break;\n")
codeWriter.write(tab + "default:\n")
codeWriter.write(tab + tab + "out << \"<unknown>\";\n")
codeWriter.write(tab + "}\n")
codeWriter.write("\n")
codeWriter.write(tab + "return out;\n")
codeWriter.write("}\n")
codeWriter.write("\n")
finally:
headerWriter.close()
codeWriter.close()
J'ai pris l'idée de @antron et je l'ai mise en œuvre différemment: générer une vraie classe enum.
Cette implémentation remplit toutes les conditions énumérées dans la question initiale, mais elle n’a actuellement qu’un seul {limitation réelle}: _: elle suppose que les valeurs enum ne sont pas fournies ou, si elles sont fournies, doivent commencer par 0 et remonter séquentiellement sans espace.
Ce n'est pas une limitation intrinsèque - simplement que je n'utilise pas de valeurs d'énumération ad-hoc. Si cela est nécessaire, on peut remplacer la recherche de vecteur par une implémentation classique de commutateur/boîtier.
La solution utilise du c ++ 17 pour les variables en ligne, mais cela peut être facilement évité si nécessaire. Il utilise également boost: trim en raison de sa simplicité.
Plus important encore, il ne faut que 30 lignes de code et pas de macros Black Magic . Le code est ci-dessous. Il est conçu pour être placé dans l'en-tête et inclus dans plusieurs modules de compilation.
Il peut être utilisé de la même façon que suggéré précédemment dans ce fil de discussion:
ENUM(Channel, int, Red, Green = 1, Blue)
std::out << "My name is " << Channel::Green;
//prints My name is Green
S'il vous plaît laissez-moi savoir si cela est utile et comment il peut encore être amélioré.
#include <boost/algorithm/string.hpp>
struct EnumSupportBase {
static std::vector<std::string> split(const std::string s, char delim) {
std::stringstream ss(s);
std::string item;
std::vector<std::string> tokens;
while (std::getline(ss, item, delim)) {
auto pos = item.find_first_of ('=');
if (pos != std::string::npos)
item.erase (pos);
boost::trim (item);
tokens.Push_back(item);
}
return tokens;
}
};
#define ENUM(EnumName, Underlying, ...) \
enum class EnumName : Underlying { __VA_ARGS__, _count }; \
struct EnumName ## Support : EnumSupportBase { \
static inline std::vector<std::string> _token_names = split(#__VA_ARGS__, ','); \
static constexpr const char* get_name(EnumName enum_value) { \
int index = (int)enum_value; \
if (index >= (int)EnumName::_count || index < 0) \
return "???"; \
else \
return _token_names[index].c_str(); \
} \
}; \
inline std::ostream& operator<<(std::ostream& os, const EnumName & es) { \
return os << EnumName##Support::get_name(es); \
}
Conformément à la demande de l'OP, voici une version simplifiée de la solution de macro laide basée sur Boost Preprosessor et Variadic Macros .
Il permet une liste simple comme la syntaxe des éléments énumérateurs avec la définition de valeurs pour des éléments spécifiques afin que
XXX_ENUM(foo,(a,b,(c,42)));
s'étend à
enum foo {
a,
b,
c=42
};
Avec les fonctions nécessaires pour sortir et faire une conversion en arrière. Cette macro existe depuis longtemps, et je ne suis pas tout à fait sûre que ce soit la méthode la plus efficace, ni la conformité, mais elle fonctionne depuis
Le code complet peut être vu en action à la fois dans Ideone et Coliru .
Sa laideur gargantuesque est au-dessus; Je l'aurais mis derrière des spoilers pour protéger vos yeux, si je savais comment, mais markdown ne m'aime pas.
La bibliothèque (fusionnée dans un seul fichier d'en-tête)
#include <boost/preprocessor.hpp>
#include <string>
#include <unordered_map>
namespace xxx
{
template<class T>
struct enum_cast_adl_helper { };
template<class E>
E enum_cast( const std::string& s )
{
return do_enum_cast(s,enum_cast_adl_helper<E>());
}
template<class E>
E enum_cast( const char* cs )
{
std::string s(cs);
return enum_cast<E>(s);
}
} // namespace xxx
#define XXX_PP_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63,N,...) N
#define XXX_PP_RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
#define XXX_PP_NARG_(...) XXX_PP_ARG_N(__VA_ARGS__)
#define XXX_PP_NARG(...) XXX_PP_NARG_(__VA_ARGS__,XXX_PP_RSEQ_N())
#define XXX_Tuple_SIZE_INTERNAL(Tuple) XXX_PP_NARG Tuple
#define XXX_Tuple_CHOICE(i) \
BOOST_PP_APPLY( \
BOOST_PP_Tuple_ELEM( \
25, i, ( \
(0), (1), (2), (3), (4), (5), (6), (7), (8), \
(9), (10), (11), (12), (13), (14), (15), (16), \
(17), (18), (19), (20), (21), (22), (23), (24) \
) ) )
#define BOOST_PP_BOOL_00 BOOST_PP_BOOL_0
#define BOOST_PP_BOOL_01 BOOST_PP_BOOL_1
#define BOOST_PP_BOOL_02 BOOST_PP_BOOL_2
#define BOOST_PP_BOOL_03 BOOST_PP_BOOL_3
#define BOOST_PP_BOOL_04 BOOST_PP_BOOL_4
#define BOOST_PP_BOOL_05 BOOST_PP_BOOL_5
#define BOOST_PP_BOOL_06 BOOST_PP_BOOL_6
#define BOOST_PP_BOOL_07 BOOST_PP_BOOL_7
#define BOOST_PP_BOOL_08 BOOST_PP_BOOL_8
#define BOOST_PP_BOOL_09 BOOST_PP_BOOL_9
#define BOOST_PP_BOOL_010 BOOST_PP_BOOL_10
#define BOOST_PP_BOOL_011 BOOST_PP_BOOL_11
#define BOOST_PP_BOOL_012 BOOST_PP_BOOL_12
#define BOOST_PP_BOOL_013 BOOST_PP_BOOL_13
#define BOOST_PP_BOOL_014 BOOST_PP_BOOL_14
#define BOOST_PP_BOOL_015 BOOST_PP_BOOL_15
#define BOOST_PP_BOOL_016 BOOST_PP_BOOL_16
#define BOOST_PP_BOOL_017 BOOST_PP_BOOL_17
#define BOOST_PP_BOOL_018 BOOST_PP_BOOL_18
#define BOOST_PP_BOOL_019 BOOST_PP_BOOL_19
#define BOOST_PP_BOOL_020 BOOST_PP_BOOL_20
#define BOOST_PP_BOOL_021 BOOST_PP_BOOL_21
#define BOOST_PP_BOOL_022 BOOST_PP_BOOL_22
#define BOOST_PP_BOOL_023 BOOST_PP_BOOL_23
#define BOOST_PP_BOOL_024 BOOST_PP_BOOL_24
#define BOOST_PP_BOOL_025 BOOST_PP_BOOL_25
#define BOOST_PP_BOOL_026 BOOST_PP_BOOL_26
#define BOOST_PP_BOOL_027 BOOST_PP_BOOL_27
#define BOOST_PP_BOOL_028 BOOST_PP_BOOL_28
#define BOOST_PP_BOOL_029 BOOST_PP_BOOL_29
#define BOOST_PP_BOOL_030 BOOST_PP_BOOL_30
#define BOOST_PP_BOOL_031 BOOST_PP_BOOL_31
#define BOOST_PP_BOOL_032 BOOST_PP_BOOL_32
#define BOOST_PP_BOOL_033 BOOST_PP_BOOL_33
#define BOOST_PP_BOOL_034 BOOST_PP_BOOL_34
#define BOOST_PP_BOOL_035 BOOST_PP_BOOL_35
#define BOOST_PP_BOOL_036 BOOST_PP_BOOL_36
#define BOOST_PP_BOOL_037 BOOST_PP_BOOL_37
#define BOOST_PP_BOOL_038 BOOST_PP_BOOL_38
#define BOOST_PP_BOOL_039 BOOST_PP_BOOL_39
#define BOOST_PP_BOOL_040 BOOST_PP_BOOL_40
#define BOOST_PP_BOOL_041 BOOST_PP_BOOL_41
#define BOOST_PP_BOOL_042 BOOST_PP_BOOL_42
#define BOOST_PP_BOOL_043 BOOST_PP_BOOL_43
#define BOOST_PP_BOOL_044 BOOST_PP_BOOL_44
#define BOOST_PP_BOOL_045 BOOST_PP_BOOL_45
#define BOOST_PP_BOOL_046 BOOST_PP_BOOL_46
#define BOOST_PP_BOOL_047 BOOST_PP_BOOL_47
#define BOOST_PP_BOOL_048 BOOST_PP_BOOL_48
#define BOOST_PP_BOOL_049 BOOST_PP_BOOL_49
#define BOOST_PP_BOOL_050 BOOST_PP_BOOL_50
#define BOOST_PP_BOOL_051 BOOST_PP_BOOL_51
#define BOOST_PP_BOOL_052 BOOST_PP_BOOL_52
#define BOOST_PP_BOOL_053 BOOST_PP_BOOL_53
#define BOOST_PP_BOOL_054 BOOST_PP_BOOL_54
#define BOOST_PP_BOOL_055 BOOST_PP_BOOL_55
#define BOOST_PP_BOOL_056 BOOST_PP_BOOL_56
#define BOOST_PP_BOOL_057 BOOST_PP_BOOL_57
#define BOOST_PP_BOOL_058 BOOST_PP_BOOL_58
#define BOOST_PP_BOOL_059 BOOST_PP_BOOL_59
#define BOOST_PP_BOOL_060 BOOST_PP_BOOL_60
#define BOOST_PP_BOOL_061 BOOST_PP_BOOL_61
#define BOOST_PP_BOOL_062 BOOST_PP_BOOL_62
#define BOOST_PP_BOOL_063 BOOST_PP_BOOL_63
#define BOOST_PP_DEC_00 BOOST_PP_DEC_0
#define BOOST_PP_DEC_01 BOOST_PP_DEC_1
#define BOOST_PP_DEC_02 BOOST_PP_DEC_2
#define BOOST_PP_DEC_03 BOOST_PP_DEC_3
#define BOOST_PP_DEC_04 BOOST_PP_DEC_4
#define BOOST_PP_DEC_05 BOOST_PP_DEC_5
#define BOOST_PP_DEC_06 BOOST_PP_DEC_6
#define BOOST_PP_DEC_07 BOOST_PP_DEC_7
#define BOOST_PP_DEC_08 BOOST_PP_DEC_8
#define BOOST_PP_DEC_09 BOOST_PP_DEC_9
#define BOOST_PP_DEC_010 BOOST_PP_DEC_10
#define BOOST_PP_DEC_011 BOOST_PP_DEC_11
#define BOOST_PP_DEC_012 BOOST_PP_DEC_12
#define BOOST_PP_DEC_013 BOOST_PP_DEC_13
#define BOOST_PP_DEC_014 BOOST_PP_DEC_14
#define BOOST_PP_DEC_015 BOOST_PP_DEC_15
#define BOOST_PP_DEC_016 BOOST_PP_DEC_16
#define BOOST_PP_DEC_017 BOOST_PP_DEC_17
#define BOOST_PP_DEC_018 BOOST_PP_DEC_18
#define BOOST_PP_DEC_019 BOOST_PP_DEC_19
#define BOOST_PP_DEC_020 BOOST_PP_DEC_20
#define BOOST_PP_DEC_021 BOOST_PP_DEC_21
#define BOOST_PP_DEC_022 BOOST_PP_DEC_22
#define BOOST_PP_DEC_023 BOOST_PP_DEC_23
#define BOOST_PP_DEC_024 BOOST_PP_DEC_24
#define BOOST_PP_DEC_025 BOOST_PP_DEC_25
#define BOOST_PP_DEC_026 BOOST_PP_DEC_26
#define BOOST_PP_DEC_027 BOOST_PP_DEC_27
#define BOOST_PP_DEC_028 BOOST_PP_DEC_28
#define BOOST_PP_DEC_029 BOOST_PP_DEC_29
#define BOOST_PP_DEC_030 BOOST_PP_DEC_30
#define BOOST_PP_DEC_031 BOOST_PP_DEC_31
#define BOOST_PP_DEC_032 BOOST_PP_DEC_32
#define BOOST_PP_DEC_033 BOOST_PP_DEC_33
#define BOOST_PP_DEC_034 BOOST_PP_DEC_34
#define BOOST_PP_DEC_035 BOOST_PP_DEC_35
#define BOOST_PP_DEC_036 BOOST_PP_DEC_36
#define BOOST_PP_DEC_037 BOOST_PP_DEC_37
#define BOOST_PP_DEC_038 BOOST_PP_DEC_38
#define BOOST_PP_DEC_039 BOOST_PP_DEC_39
#define BOOST_PP_DEC_040 BOOST_PP_DEC_40
#define BOOST_PP_DEC_041 BOOST_PP_DEC_41
#define BOOST_PP_DEC_042 BOOST_PP_DEC_42
#define BOOST_PP_DEC_043 BOOST_PP_DEC_43
#define BOOST_PP_DEC_044 BOOST_PP_DEC_44
#define BOOST_PP_DEC_045 BOOST_PP_DEC_45
#define BOOST_PP_DEC_046 BOOST_PP_DEC_46
#define BOOST_PP_DEC_047 BOOST_PP_DEC_47
#define BOOST_PP_DEC_048 BOOST_PP_DEC_48
#define BOOST_PP_DEC_049 BOOST_PP_DEC_49
#define BOOST_PP_DEC_050 BOOST_PP_DEC_50
#define BOOST_PP_DEC_051 BOOST_PP_DEC_51
#define BOOST_PP_DEC_052 BOOST_PP_DEC_52
#define BOOST_PP_DEC_053 BOOST_PP_DEC_53
#define BOOST_PP_DEC_054 BOOST_PP_DEC_54
#define BOOST_PP_DEC_055 BOOST_PP_DEC_55
#define BOOST_PP_DEC_056 BOOST_PP_DEC_56
#define BOOST_PP_DEC_057 BOOST_PP_DEC_57
#define BOOST_PP_DEC_058 BOOST_PP_DEC_58
#define BOOST_PP_DEC_059 BOOST_PP_DEC_59
#define BOOST_PP_DEC_060 BOOST_PP_DEC_60
#define BOOST_PP_DEC_061 BOOST_PP_DEC_61
#define BOOST_PP_DEC_062 BOOST_PP_DEC_62
#define BOOST_PP_DEC_063 BOOST_PP_DEC_63
#define XXX_TO_NUMx(x) 0 ## x
#define XXX_TO_NUM(x) BOOST_PP_ADD(0,XXX_TO_NUMx(x))
#define XXX_STRINGIZEX(x) # x
#define XXX_VSTRINGIZE_SINGLE(a,b,x) XXX_STRINGIZE(x)
#define XXX_VSTRINGIZE_Tuple(tpl) XXX_Tuple_FOR_EACH(XXX_VSTRINGIZE_SINGLE,,tpl)
#define XXX_Tuple_SIZE(Tuple) XXX_TO_NUM(XXX_Tuple_CHOICE(XXX_Tuple_SIZE_INTERNAL(Tuple)))
#define XXX_Tuple_FOR_EACH(MACRO,DATA,Tuple) BOOST_PP_LIST_FOR_EACH(MACRO,DATA,BOOST_PP_Tuple_TO_LIST(XXX_Tuple_SIZE(Tuple),Tuple))
#define XXX_STRINGIZE(x) XXX_STRINGIZEX(x)
#define XXX_VSTRINGIZE(...) XXX_VSTRINGIZE_Tuple((__VA_ARGS__))
#define XXX_CAST_TO_VOID_ELEMENT(r,data,elem) (void)(elem);
#define XXX_CAST_TO_VOID_INTERNAL(Tuple) XXX_Tuple_FOR_EACH(XXX_CAST_TO_VOID_ELEMENT,,Tuple)
#define XXX_CAST_TO_VOID(...) XXX_CAST_TO_VOID_INTERNAL((__VA_ARGS__))
#define XXX_ENUM_EXTRACT_SP(en) BOOST_PP_Tuple_ELEM(XXX_Tuple_SIZE(en),0,en) = BOOST_PP_Tuple_ELEM(XXX_Tuple_SIZE(en),1,en)
#define XXX_ENUM_ELEMENT(r,data,elem) BOOST_PP_IF( XXX_Tuple_SIZE(elem), XXX_ENUM_EXTRACT_SP(elem), elem) ,
#define XXX_ENUM_EXTRACT_ELEMENT(en) BOOST_PP_Tuple_ELEM(XXX_Tuple_SIZE(en),0,en)
#define XXX_ENUM_CASE_ELEMENT(en) BOOST_PP_IF( XXX_Tuple_SIZE(en), XXX_ENUM_EXTRACT_ELEMENT(en), en )
#define XXX_ENUM_CASE(r,data,elem) case data :: XXX_ENUM_CASE_ELEMENT(elem) : return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem));
#define XXX_ENUM_IFELSE(r,data,elem) else if( en == data :: XXX_ENUM_CASE_ELEMENT(elem)) { return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)); }
#define XXX_ENUM_CASTLIST(r,data,elem) { XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },
#define XXX_ENUM_QUALIFIED_CASTLIST(r,data,elem) { #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },
#define XXX_ENUM_INTERNAL(TYPE,NAME,Tuple) \
enum TYPE \
{ \
XXX_Tuple_FOR_EACH(XXX_ENUM_ELEMENT,,Tuple) \
BOOST_PP_CAT(last_enum_,NAME) \
}; \
\
inline \
const char* to_string( NAME en ) \
{ \
if(false) \
{ \
} \
XXX_Tuple_FOR_EACH(XXX_ENUM_IFELSE,NAME,Tuple) \
else if( en == NAME :: BOOST_PP_CAT(last_enum_,NAME) ) \
{ \
return XXX_VSTRINGIZE(NAME,::,BOOST_PP_CAT(last_enum_,NAME)); \
} \
else \
{ \
return "Invalid enum value specified for " # NAME; \
} \
} \
\
inline \
std::ostream& operator<<( std::ostream& os, const NAME& en ) \
{ \
os << to_string(en); \
return os; \
} \
\
inline \
NAME do_enum_cast( const std::string& s, const ::xxx::enum_cast_adl_helper<NAME>& ) \
{ \
static const std::unordered_map<std::string,NAME> map = \
{ \
XXX_Tuple_FOR_EACH(XXX_ENUM_CASTLIST,NAME,Tuple) \
XXX_Tuple_FOR_EACH(XXX_ENUM_QUALIFIED_CASTLIST,NAME,Tuple) \
}; \
\
auto cit = map.find(s); \
if( cit == map.end() ) \
{ \
throw std::runtime_error("Invalid value to cast to enum"); \
} \
return cit->second; \
}
#define XXX_ENUM(NAME,Tuple) XXX_ENUM_INTERNAL(NAME,NAME,Tuple)
#define XXX_ENUM_CLASS(NAME,Tuple) XXX_ENUM_INTERNAL(class NAME,NAME,Tuple)
#define XXX_ENUM_CLASS_TYPE(NAME,TYPE,Tuple) XXX_ENUM_INTERNAL(class NAME : TYPE,NAME,Tuple)
#define XXX_ENUM_TYPE(NAME,TYPE,Tuple) XXX_ENUM_INTERNAL(NAME : TYPE,NAME,Tuple)
Usage
#include "xxx_enum.h" // the above lib
#include <iostream>
XXX_ENUM(foo,(a,b,(c,42)));
int main()
{
std::cout << "foo::a = " << foo::a <<'\n';
std::cout << "(int)foo::c = " << (int)foo::c <<'\n';
std::cout << "to_string(foo::b) = " << to_string(foo::b) <<'\n';
std::cout << "xxx::enum_cast<foo>(\"b\") = " << xxx::enum_cast<foo>("b") <<'\n';
}
Compilation (copier coller l'en-tête dans main.cpp)
> g++ --version | sed 1q
g++ (GCC) 4.9.2
> g++ -std=c++14 -pedantic -Wall -Wextra main.cpp
main.cpp:268:31: warning: extra ';' [-Wpedantic]
XXX_ENUM(foo,(a,b,(c,42)));
^
Sortie
foo::a = foo::a
(int)foo::c = 42
to_string(foo::b) = foo::b
xxx::enum_cast<foo>("b") = foo::b
La bibliothèque magic_enum fournit les fonctionnalités énumération à chaîne et chaîne à énumération, consiste en un seul fichier en-tête et utilise la fonctionnalité C++ - 17. Exemple d'utilisation du readme:
_#include "magic_enum.hpp"
enum Color { RED = 2, BLUE = 4, GREEN = 8 };
Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"
std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name)
if (color.has_value()) {
// color.value() -> Color::GREEN
};
_Cela fait longtemps que je suis également frustré par ce problème, ainsi que par le problème de la conversion correcte d'un type en chaîne. Cependant, pour le dernier problème, j'ai été surpris par la solution expliquée dans Est-il possible d'imprimer le type d'une variable en C++ standard? , en utilisant l'idée de Puis-je obtenir des noms de type C++ de manière constexpr? . En utilisant cette technique, une fonction analogue peut être construite pour obtenir une valeur enum sous forme de chaîne:
#include <iostream>
using namespace std;
class static_string
{
const char* const p_;
const std::size_t sz_;
public:
typedef const char* const_iterator;
template <std::size_t N>
constexpr static_string(const char(&a)[N]) noexcept
: p_(a)
, sz_(N - 1)
{}
constexpr static_string(const char* p, std::size_t N) noexcept
: p_(p)
, sz_(N)
{}
constexpr const char* data() const noexcept { return p_; }
constexpr std::size_t size() const noexcept { return sz_; }
constexpr const_iterator begin() const noexcept { return p_; }
constexpr const_iterator end() const noexcept { return p_ + sz_; }
constexpr char operator[](std::size_t n) const
{
return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
}
};
inline std::ostream& operator<<(std::ostream& os, static_string const& s)
{
return os.write(s.data(), s.size());
}
/// \brief Get the name of a type
template <class T>
static_string typeName()
{
#ifdef __clang__
static_string p = __PRETTY_FUNCTION__;
return static_string(p.data() + 30, p.size() - 30 - 1);
#Elif defined(_MSC_VER)
static_string p = __FUNCSIG__;
return static_string(p.data() + 37, p.size() - 37 - 7);
#endif
}
namespace details
{
template <class Enum>
struct EnumWrapper
{
template < Enum enu >
static static_string name()
{
#ifdef __clang__
static_string p = __PRETTY_FUNCTION__;
static_string enumType = typeName<Enum>();
return static_string(p.data() + 73 + enumType.size(), p.size() - 73 - enumType.size() - 1);
#Elif defined(_MSC_VER)
static_string p = __FUNCSIG__;
static_string enumType = typeName<Enum>();
return static_string(p.data() + 57 + enumType.size(), p.size() - 57 - enumType.size() - 7);
#endif
}
};
}
/// \brief Get the name of an enum value
template <typename Enum, Enum enu>
static_string enumName()
{
return details::EnumWrapper<Enum>::template name<enu>();
}
enum class Color
{
Blue = 0,
Yellow = 1
};
int main()
{
std::cout << "_" << typeName<Color>() << "_" << std::endl;
std::cout << "_" << enumName<Color, Color::Blue>() << "_" << std::endl;
return 0;
}
Le code ci-dessus n'a été testé que sur Clang (voir https://ideone.com/je5Quv ) et VS2015, mais devrait pouvoir être adapté à d'autres compilateurs en bidouillant un peu les constantes de nombre entier. Bien sûr, il utilise toujours des macros sous le capot, mais au moins une d'entre elles n'a pas besoin d'accéder à l'implémentation enum.
Je ne suis pas sûr si cette approche est déjà couverte dans l'une des autres réponses (en fait, voir ci-dessous). J'ai rencontré le problème plusieurs fois et je n'ai pas trouvé de solution qui n'utilise pas de macros obfusquées ni de bibliothèques tierces. J'ai donc décidé d'écrire ma propre version macro obfusquée.
Ce que je veux activer est l'équivalent de
enum class test1 { ONE, TWO = 13, SIX };
std::string toString(const test1& e) { ... }
int main() {
test1 x;
std::cout << toString(x) << "\n";
std::cout << toString(test1::TWO) << "\n";
std::cout << static_cast<std::underlying_type<test1>::type>(test1::TWO) << "\n";
//std::cout << toString(123);// invalid
}
qui devrait imprimer
ONE
TWO
13
Je ne suis pas fan de macros. Cependant, à moins que c ++ ne prenne en charge de manière native la conversion d’énums en chaînes, vous devez utiliser une sorte de génération de code et/ou de macros (et je doute que cela se produise trop tôt). J'utilise un X-macro :
// x_enum.h
#include <string>
#include <map>
#include <type_traits>
#define x_begin enum class x_name {
#define x_val(X) X
#define x_value(X,Y) X = Y
#define x_end };
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end
#define x_begin inline std::string toString(const x_name& e) { \
static std::map<x_name,std::string> names = {
#define x_val(X) { x_name::X , #X }
#define x_value(X,Y) { x_name::X , #X }
#define x_end }; return names[e]; }
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end
#undef x_name
#undef x_enum_def
Il s’agit pour la plupart de symboles définissant et indéfinis que l’utilisateur passera en paramètre à X-marco via un include. L'usage est comme ça
#define x_name test1
#define x_enum_def x_begin x_val(ONE) , \
x_value(TWO,13) , \
x_val(SIX) \
x_end
#include "x_enum.h"
Notez que je n'ai pas encore inclus le choix du type sous-jacent. Je n'en avais pas besoin jusqu'à présent, mais il devrait être facile de modifier en code pour permettre cela.
Ce n’est qu’après avoir écrit cela que je me suis rendu compte que c’est assez semblable à eferions répond . Peut-être que je l'avais lu auparavant et que c'était peut-être la principale source d'inspiration. Je n'arrivais toujours pas à comprendre les macros X avant d'écrire les miennes;).
Tant que vous êtes prêt à écrire une paire .h/.cpp distincte pour chaque énumération interrogeable, cette solution fonctionne avec presque la même syntaxe et les mêmes fonctionnalités qu’une énumération c ++ classique:
// MyEnum.h
#include <EnumTraits.h>
#ifndef ENUM_INCLUDE_MULTI
#pragma once
#end if
enum MyEnum : int ETRAITS
{
EDECL(AAA) = -8,
EDECL(BBB) = '8',
EDECL(CCC) = AAA + BBB
};
Le fichier .cpp contient 3 lignes de code passe-partout:
// MyEnum.cpp
#define ENUM_DEFINE MyEnum
#define ENUM_INCLUDE <MyEnum.h>
#include <EnumTraits.inl>
Exemple d'utilisation:
for (MyEnum value : EnumTraits<MyEnum>::GetValues())
std::cout << EnumTraits<MyEnum>::GetName(value) << std::endl;
Code
Cette solution nécessite 2 fichiers sources:
// EnumTraits.h
#pragma once
#include <string>
#include <unordered_map>
#include <vector>
#define ETRAITS
#define EDECL(x) x
template <class ENUM>
class EnumTraits
{
public:
static const std::vector<ENUM>& GetValues()
{
return values;
}
static ENUM GetValue(const char* name)
{
auto match = valueMap.find(name);
return (match == valueMap.end() ? ENUM() : match->second);
}
static const char* GetName(ENUM value)
{
auto match = nameMap.find(value);
return (match == nameMap.end() ? nullptr : match->second);
}
public:
EnumTraits() = delete;
using vector_type = std::vector<ENUM>;
using name_map_type = std::unordered_map<ENUM, const char*>;
using value_map_type = std::unordered_map<std::string, ENUM>;
private:
static const vector_type values;
static const name_map_type nameMap;
static const value_map_type valueMap;
};
struct EnumInitGuard{ constexpr const EnumInitGuard& operator=(int) const { return *this; } };
template <class T> constexpr T& operator<<=(T&& x, const EnumInitGuard&) { return x; }
...et
// EnumTraits.inl
#define ENUM_INCLUDE_MULTI
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL
using EnumType = ENUM_DEFINE;
using TraitsType = EnumTraits<EnumType>;
using VectorType = typename TraitsType::vector_type;
using NameMapType = typename TraitsType::name_map_type;
using ValueMapType = typename TraitsType::value_map_type;
using NamePairType = typename NameMapType::value_type;
using ValuePairType = typename ValueMapType::value_type;
#define ETRAITS ; const VectorType TraitsType::values
#define EDECL(x) EnumType::x <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL
#define ETRAITS ; const NameMapType TraitsType::nameMap
#define EDECL(x) NamePairType(EnumType::x, #x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL
#define ETRAITS ; const ValueMapType TraitsType::valueMap
#define EDECL(x) ValuePairType(#x, EnumType::x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL
Explication
Cette implémentation exploite le fait que la liste encadrée d'éléments d'une définition Enum peut également être utilisée comme liste d'initialisation masquée pour l'initialisation du membre de la classe.
Lorsque ETRAITS est évalué dans le contexte de EnumTraits.inl, Devient une définition de membre statique pour la classe EnumTraits<>.
La macro EDECL transforme chaque membre enum en valeurs de liste d'initialisation qui sont ensuite transmises au constructeur du membre afin de renseigner les informations d'énumération.
La classe EnumInitGuard est conçue pour consommer les valeurs d'initialiseur d'énumération, puis se réduire, laissant une liste pure de données d'énumération.
Avantages
c++- comme syntaxe- Fonctionne de la même manière pour
enumetenum class(* presque) - Fonctionne pour les types
enumavec n'importe quel type sous-jacent numérique - Fonctionne pour les types
enumavec des valeurs d'initialisation automatiques, explicites et fragmentées - Travaux de renommage en masse (liaison intellisense préservée)
- Seulement 5 symboles de préprocesseur (3 globaux)
* Contrairement à enums, les initialiseurs dans les types enum class qui référencent d'autres valeurs du même enum doivent avoir ces valeurs entièrement qualifiées
Désavantages
- Requiert une paire
.h/.cppdistincte pour chaque objet interrogeableenum - Dépend de la magie
macroetincludecompliquée - Les erreurs de syntaxe mineures éclatent en erreurs beaucoup plus grandes
- Définir des variables
classounamespaceest non-trivial - Pas d'initialisation du temps de compilation
Commentaires
Intellisense se plaindra un peu de l'accès des membres privés lors de l'ouverture de EnumTraits.inl, mais comme les macros développées définissent en fait les membres de la classe, cela ne pose pas vraiment de problème.
Le bloc #ifndef ENUM_INCLUDE_MULTI en haut du fichier d'en-tête est un inconvénient mineur qui pourrait probablement être réduit à une macro ou quelque chose du genre, mais suffisamment petit pour supporter sa taille actuelle.
Pour déclarer une énumération de périmètre d'espace de nom, il faut d'abord que l'énumération soit déclarée avant à l'intérieur de son étendue d'espace de nom, puis définie dans l'espace de nom global. De plus, tous les initialiseurs d'énumération utilisant des valeurs du même enum doivent avoir ces valeurs entièrement qualifiées.
namespace ns { enum MyEnum : int; }
enum ns::MyEnum : int ETRAITS
{
EDECL(AAA) = -8,
EDECL(BBB) = '8',
EDECL(CCC) = ns::MyEnum::AAA + ns::MyEnum::BBB
}
Ma réponse est ici.
En utilisant cette bibliothèque (créée par moi), vous pouvez obtenir les noms des constantes enum: https://github.com/Neargye/nameof
// Name of enum
auto c = Color::RED;
NAMEOF_ENUM(c) -> "RED"
// Name of enum
nameof::nameof_enum(c) -> "RED"
constexpr auto cx_name = NAMEOF_ENUM(c);
static_assert("RED" == cx_name);
Cette bibliothèque utilise un hack spécifique au compilateur (basé sur __PRETTY_FUNCTION__/__FUNCSIG__), qui fonctionne sur Clang> = 5, MSVC> = 15.3 et GCC> = 9.
Solutions utilisant enum au sein de la classe/struct (opérateurs par défaut avec des membres publics) et des opérateurs surchargés:
struct Color
{
enum Enum { RED, GREEN, BLUE };
Enum e;
Color() {}
Color(Enum e) : e(e) {}
Color operator=(Enum o) { e = o; return *this; }
Color operator=(Color o) { e = o.e; return *this; }
bool operator==(Enum o) { return e == o; }
bool operator==(Color o) { return e == o.e; }
operator Enum() const { return e; }
std::string toString() const
{
switch (e)
{
case Color::RED:
return "red";
case Color::GREEN:
return "green";
case Color::BLUE:
return "blue";
default:
return "unknown";
}
}
};
De l'extérieur, cela ressemble presque exactement à un enum de classe:
Color red;
red = Color::RED;
Color blue = Color::BLUE;
cout << red.toString() << " " << Color::GREEN << " " << blue << endl;
Cela produira "rouge 1 2". Vous pourriez éventuellement surcharger << pour que la sortie bleue devienne une chaîne (bien que cela puisse causer une ambiguïté, ce n'est pas possible), mais cela ne fonctionnerait pas avec Color :: GREEN car elle ne se convertissait pas automatiquement en Color.
Le but d'une conversion implicite en Enum (qui convertit implicitement en int ou type donné) est de pouvoir effectuer:
Color color;
switch (color) ...
Cela fonctionne, mais cela signifie également que cela fonctionne aussi:
int i = color;
Avec une classe enum, la compilation ne serait pas ... .. Vous devez faire attention si vous surchargez deux fonctions prenant l'enum et un entier, ou supprimez la conversion implicite ...
Une autre solution consisterait à utiliser une classe enum réelle et des membres statiques:
struct Color
{
enum class Enum { RED, GREEN, BLUE };
static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;
//same as previous...
};
Cela prend peut-être plus d'espace et est plus long à créer, mais provoque une erreur de compilation pour les conversions int implicites. J'utiliserais celui-ci à cause de ça!
Cependant, il y a sûrement des frais généraux avec cela, mais je pense que c'est simplement plus simple et que son apparence est meilleure que celle des autres codes que j'ai vus. Il existe également un potentiel d’ajout de fonctionnalités, qui pourraient toutes être définies dans la classe.
Edit : cela fonctionne et la plupart peuvent être compilés avant exécution:
class Color
{
public:
enum class Enum { RED, GREEN, BLUE };
static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;
constexpr Color() : e(Enum::RED) {}
constexpr Color(Enum e) : e(e) {}
constexpr bool operator==(Enum o) const { return e == o; }
constexpr bool operator==(Color o) const { return e == o.e; }
constexpr operator Enum() const { return e; }
Color& operator=(Enum o) { const_cast<Enum>(this->e) = o; return *this; }
Color& operator=(Color o) { const_cast<Enum>(this->e) = o.e; return *this; }
std::string toString() const
{
switch (e)
{
case Enum::RED:
return "red";
case Enum::GREEN:
return "green";
case Enum::BLUE:
return "blue";
default:
return "unknown";
}
}
private:
const Enum e;
};
Solution très simple avec une grosse contrainte: vous ne pouvez pas affecter de valeurs personnalisées à des valeurs enum, mais avec la regex appropriée, vous le pouvez. vous pouvez également ajouter une carte pour les traduire en valeurs enum sans plus d'effort:
#include <vector>
#include <string>
#include <regex>
#include <iterator>
std::vector<std::string> split(const std::string& s,
const std::regex& delim = std::regex(",\\s*"))
{
using namespace std;
vector<string> cont;
copy(regex_token_iterator<string::const_iterator>(s.begin(), s.end(), delim, -1),
regex_token_iterator<string::const_iterator>(),
back_inserter(cont));
return cont;
}
#define EnumType(Type, ...) enum class Type { __VA_ARGS__ }
#define EnumStrings(Type, ...) static const std::vector<std::string> \
Type##Strings = split(#__VA_ARGS__);
#define EnumToString(Type, ...) EnumType(Type, __VA_ARGS__); \
EnumStrings(Type, __VA_ARGS__)
Exemple d'utilisation:
EnumToString(MyEnum, Red, Green, Blue);
EDIT: vérifier ci-dessous pour une version plus récente
Comme mentionné ci-dessus, N4113 est la solution finale à ce problème, mais nous devrons attendre plus d'un an pour le voir paraître.
En attendant, si vous voulez une telle fonctionnalité, vous aurez besoin de recourir à de "simples" modèles et à la magie du préprocesseur.
Enumérateur
template<typename T>
class Enum final
{
const char* m_name;
const T m_value;
static T m_counter;
public:
Enum(const char* str, T init = m_counter) : m_name(str), m_value(init) {m_counter = (init + 1);}
const T value() const {return m_value;}
const char* name() const {return m_name;}
};
template<typename T>
T Enum<T>::m_counter = 0;
#define ENUM_TYPE(x) using Enum = Enum<x>;
#define ENUM_DECL(x,...) x(#x,##__VA_ARGS__)
#define ENUM(...) const Enum ENUM_DECL(__VA_ARGS__);
Usage
#include <iostream>
//the initialization order should be correct in all scenarios
namespace Level
{
ENUM_TYPE(std::uint8)
ENUM(OFF)
ENUM(SEVERE)
ENUM(WARNING)
ENUM(INFO, 10)
ENUM(DEBUG)
ENUM(ALL)
}
namespace Example
{
ENUM_TYPE(long)
ENUM(A)
ENUM(B)
ENUM(C, 20)
ENUM(D)
ENUM(E)
ENUM(F)
}
int main(int argc, char** argv)
{
Level::Enum lvl = Level::WARNING;
Example::Enum ex = Example::C;
std::cout << lvl.value() << std::endl; //2
std::cout << ex.value() << std::endl; //20
}
Explication simple
Enum<T>::m_counter est défini sur 0 dans chaque déclaration d'espace de noms.
(Quelqu'un pourrait-il me signaler où ^^ ce comportement ^^ est mentionné dans la norme?)
La magie du préprocesseur automatise la déclaration des énumérateurs.
Désavantages
- Ce n'est pas un vrai type
enum, donc ne peut pas être promu en int - Ne peut pas être utilisé dans les cas de commutation
Solution alternative
Celui-ci sacrifie la numérotation des lignes (pas vraiment) mais peut être utilisé sur des cas de commutation.
#define ENUM_TYPE(x) using type = Enum<x>
#define ENUM(x) constexpr type x{__LINE__,#x}
template<typename T>
struct Enum final
{
const T value;
const char* name;
constexpr operator const T() const noexcept {return value;}
constexpr const char* operator&() const noexcept {return name;}
};
Errata
#line 0 est en conflit avec -pedantic sur GCC et clang.
Workaround
Commencez par #line 1 et soustrayez 1 de __LINE__.
Ou n'utilisez pas -pedantic.
.__ Et pendant que nous y sommes, évitez VC++ à tout prix, cela a toujours été une blague de compilateur.
Usage
#include <iostream>
namespace Level
{
ENUM_TYPE(short);
#line 0
ENUM(OFF);
ENUM(SEVERE);
ENUM(WARNING);
#line 10
ENUM(INFO);
ENUM(DEBUG);
ENUM(ALL);
#line <next line number> //restore the line numbering
};
int main(int argc, char** argv)
{
std::cout << Level::OFF << std::endl; // 0
std::cout << &Level::OFF << std::endl; // OFF
std::cout << Level::INFO << std::endl; // 10
std::cout << &Level::INFO << std::endl; // INFO
switch(/* any integer or integer-convertible type */)
{
case Level::OFF:
//...
break;
case Level::SEVERE:
//...
break;
//...
}
return 0;
}
Mise en oeuvre et utilisation réelles
r3dVoxel - Enum
r3dVoxel - ELoggingLevel
Référence rapide
Vous pouvez utiliser une bibliothèque de réflexion, comme Ponder :
enum class MyEnum
{
Zero = 0,
One = 1,
Two = 2
};
ponder::Enum::declare<MyEnum>()
.value("Zero", MyEnum::Zero)
.value("One", MyEnum::One)
.value("Two", MyEnum::Two);
ponder::EnumObject zero(MyEnum::Zero);
zero.name(); // -> "Zero"
La solution suivante est basée sur un std::array<std::string,N> pour une énumération donnée.
Pour la conversion de enum à std::string, nous pouvons simplement convertir l'énumération en size_t et rechercher la chaîne dans le tableau. L'opération est O(1) et ne nécessite aucune allocation de tas.
#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <string>
#include <array>
#include <iostream>
#define STRINGIZE(s, data, elem) BOOST_PP_STRINGIZE(elem)
// ENUM
// ============================================================================
#define ENUM(X, SEQ) \
struct X { \
enum Enum {BOOST_PP_SEQ_ENUM(SEQ)}; \
static const std::array<std::string,BOOST_PP_SEQ_SIZE(SEQ)> array_of_strings() { \
return {{BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(STRINGIZE, 0, SEQ))}}; \
} \
static std::string to_string(Enum e) { \
auto a = array_of_strings(); \
return a[static_cast<size_t>(e)]; \
} \
}
Pour la conversion de std::string à enum, nous devrions effectuer une recherche linéaire sur le tableau et convertir l'index du tableau en enum.
Essayez-le ici avec des exemples d'utilisation: http://coliru.stacked-crooked.com/a/e4212f93bee65076
Edit: Retravaillé ma solution pour que l'énumération personnalisée puisse être utilisée dans une classe.
ma solution est sans utilisation de macro.
avantages:
- tu vois exactement ce que tu fais
- l'accès est avec des cartes de hachage, donc bon pour de nombreux énumérations valorisées
- pas besoin de prendre en compte des valeurs d'ordre ou non consécutives
- à la fois enum to string et string to enum translation, alors que la valeur enum ajoutée doit être ajoutée à un seul endroit supplémentaire
désavantages:
- vous devez répliquer toutes les valeurs enums sous forme de texte
- l'accès dans la carte de hachage doit tenir compte du cas de chaîne
- maintenance si l'ajout de valeurs est pénible - il faut ajouter à la fois l'énumération et la traduction directe de la carte
donc ... jusqu'au jour où C++ implémentera la fonctionnalité C # Enum.Parse, je serai coincé avec ceci:
#include <unordered_map>
enum class Language
{ unknown,
Chinese,
English,
French,
German
// etc etc
};
class Enumerations
{
public:
static void fnInit(void);
static std::unordered_map <std::wstring, Language> m_Language;
static std::unordered_map <Language, std::wstring> m_invLanguage;
private:
static void fnClear();
static void fnSetValues(void);
static void fnInvertValues(void);
static bool m_init_done;
};
std::unordered_map <std::wstring, Language> Enumerations::m_Language = std::unordered_map <std::wstring, Language>();
std::unordered_map <Language, std::wstring> Enumerations::m_invLanguage = std::unordered_map <Language, std::wstring>();
void Enumerations::fnInit()
{
fnClear();
fnSetValues();
fnInvertValues();
}
void Enumerations::fnClear()
{
m_Language.clear();
m_invLanguage.clear();
}
void Enumerations::fnSetValues(void)
{
m_Language[L"unknown"] = Language::unknown;
m_Language[L"Chinese"] = Language::Chinese;
m_Language[L"English"] = Language::English;
m_Language[L"French"] = Language::French;
m_Language[L"German"] = Language::German;
// and more etc etc
}
void Enumerations::fnInvertValues(void)
{
for (auto it = m_Language.begin(); it != m_Language.end(); it++)
{
m_invLanguage[it->second] = it->first;
}
}
// usage -
//Language aLanguage = Language::English;
//wstring sLanguage = Enumerations::m_invLanguage[aLanguage];
//wstring sLanguage = L"French" ;
//Language aLanguage = Enumerations::m_Language[sLanguage];
(Analogique de https://stackoverflow.com/a/54967187/2338477 , légèrement modifié).
Voici ma propre solution avec minimum définir la magie et le soutien des assignations individuelles enum.
Voici le fichier d'en-tête:
#pragma once
#include <string>
#include <map>
#include <regex>
template <class Enum>
class EnumReflect
{
public:
static const char* getEnums() { return ""; }
};
//
// Just a container for each enumeration type.
//
template <class Enum>
class EnumReflectBase
{
public:
static std::map<std::string, int> enum2int;
static std::map<int, std::string> int2enum;
static void EnsureEnumMapReady( const char* enumsInfo )
{
if (*enumsInfo == 0 || enum2int.size() != 0 )
return;
// Should be called once per each enumeration.
std::string senumsInfo(enumsInfo);
std::regex re("^([a-zA-Z_][a-zA-Z0-9_]+) *=? *([^,]*)(,|$) *"); // C++ identifier to optional " = <value>"
std::smatch sm;
int value = 0;
for (; regex_search(senumsInfo, sm, re); senumsInfo = sm.suffix(), value++)
{
string enumName = sm[1].str();
string enumValue = sm[2].str();
if (enumValue.length() != 0)
value = atoi(enumValue.c_str());
enum2int[enumName] = value;
int2enum[value] = enumName;
}
}
};
template <class Enum>
std::map<std::string, int> EnumReflectBase<Enum>::enum2int;
template <class Enum>
std::map<int, std::string> EnumReflectBase<Enum>::int2enum;
#define DECLARE_ENUM(name, ...) \
enum name { __VA_ARGS__ }; \
template <> \
class EnumReflect<##name>: public EnumReflectBase<##name> { \
public: \
static const char* getEnums() { return #__VA_ARGS__; } \
};
/*
Basic usage:
Declare enumeration:
DECLARE_ENUM( enumName,
enumValue1,
enumValue2,
enumValue3 = 5,
// comment
enumValue4
);
Conversion logic:
From enumeration to string:
printf( EnumToString(enumValue3).c_str() );
From string to enumeration:
enumName value;
if( !StringToEnum("enumValue4", value) )
printf("Conversion failed...");
*/
//
// Converts enumeration to string, if not found - empty string is returned.
//
template <class T>
std::string EnumToString(T t)
{
EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
auto& int2enum = EnumReflect<T>::int2enum;
auto it = int2enum.find(t);
if (it == int2enum.end())
return "";
return it->second;
}
//
// Converts string to enumeration, if not found - false is returned.
//
template <class T>
bool StringToEnum(const char* enumName, T& t)
{
EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
auto& enum2int = EnumReflect<T>::enum2int;
auto it = enum2int.find(enumName);
if (it == enum2int.end())
return false;
t = (T) it->second;
return true;
}
Et voici un exemple d’application de test:
DECLARE_ENUM(TestEnum,
ValueOne,
ValueTwo,
ValueThree = 5,
ValueFour = 7
);
DECLARE_ENUM(TestEnum2,
ValueOne2 = -1,
ValueTwo2,
ValueThree2 = -4,
ValueFour2
);
void main(void)
{
string sName1 = EnumToString(ValueOne);
string sName2 = EnumToString(ValueTwo);
string sName3 = EnumToString(ValueThree);
string sName4 = EnumToString(ValueFour);
TestEnum t1, t2, t3, t4, t5 = ValueOne;
bool b1 = StringToEnum(sName1.c_str(), t1);
bool b2 = StringToEnum(sName2.c_str(), t2);
bool b3 = StringToEnum(sName3.c_str(), t3);
bool b4 = StringToEnum(sName4.c_str(), t4);
bool b5 = StringToEnum("Unknown", t5);
string sName2_1 = EnumToString(ValueOne2);
string sName2_2 = EnumToString(ValueTwo2);
string sName2_3 = EnumToString(ValueThree2);
string sName2_4 = EnumToString(ValueFour2);
TestEnum2 t2_1, t2_2, t2_3, t2_4, t2_5 = ValueOne2;
bool b2_1 = StringToEnum(sName2_1.c_str(), t2_1);
bool b2_2 = StringToEnum(sName2_2.c_str(), t2_2);
bool b2_3 = StringToEnum(sName2_3.c_str(), t2_3);
bool b2_4 = StringToEnum(sName2_4.c_str(), t2_4);
bool b2_5 = StringToEnum("Unknown", t2_5);
La version mise à jour du même fichier d'en-tête sera conservée ici:
https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/EnumReflect.h
J'ai écrit une bibliothèque pour résoudre ce problème, tout se passe en temps de compilation, à l'exception du message.
Usage:
Utilisez la macro DEF_MSG pour définir une paire macro-message:
DEF_MSG(CODE_OK, "OK!")
DEF_MSG(CODE_FAIL, "Fail!")
CODE_OK est la macro à utiliser et "OK!" est le message correspondant.
Utilisez get_message() ou juste gm() pour obtenir le message:
get_message(CODE_FAIL); // will return "Fail!"
gm(CODE_FAIL); // works exactly the same as above
Utilisez MSG_NUM pour savoir combien de macros ont été définies. Cela va automatiquement augmenter, vous n'avez rien à faire.
Messages prédéfinis:
MSG_OK: OK
MSG_BOTTOM: Message bottom
Projet: libcodemsg
La bibliothèque ne crée pas de données supplémentaires. Tout se passe en temps de compilation. Dans message_def.h, il génère une enum appelée MSG_CODE; dans message_def.c, il génère une variable qui contient toutes les chaînes dans static const char* _g_messages[].
Dans ce cas, la bibliothèque est limitée à créer une seule variable enum. C'est idéal pour les valeurs de retour, par exemple:
MSG_CODE foo(void) {
return MSG_OK; // or something else
}
MSG_CODE ret = foo();
if (MSG_OK != ret) {
printf("%s\n", gm(ret););
}
Une autre chose qui me plaît dans cette conception est que vous pouvez gérer les définitions de message dans différents fichiers.
J'ai trouvé la solution à cette question semble beaucoup mieux.
Le moyen le plus simple?
Utilisez Ada: Enumeration'Image( Value ) fait exactement ce que vous voulez. Si vous vraiment avez besoin de C++, vous pouvez essayer d’exporter la fonction:
Function To_String( Input : Enumeration ) return Interfaces.C.Strings.chars_ptr is
( Interfaces.C.Strings.New_String( Enumeration'Image(Input) ) )
with Export, Convention => C;
Ma réponse est ici.
Vous pouvez obtenir des noms de valeur enum et ces index simultanément sous forme de deque de chaîne.
Cette méthode nécessite seulement peu de copier/coller et éditer.
Le résultat obtenu a besoin d'être transtypé de size_t à type de classe enum lorsque vous avez besoin de la valeur de type de classe enum, mais je pense que c'est un moyen très portable et puissant de traiter la classe enum.
enum class myenum
{
one = 0,
two,
three,
};
deque<string> ssplit(const string &_src, boost::regex &_re)
{
boost::sregex_token_iterator it(_src.begin(), _src.end(), _re, -1);
boost::sregex_token_iterator e;
deque<string> tokens;
while (it != e)
tokens.Push_back(*it++);
return std::move(tokens);
}
int main()
{
regex re(",");
deque<string> tokens = ssplit("one,two,three", re);
for (auto &t : tokens) cout << t << endl;
getchar();
return 0;
}
#define ENUM_MAKE(TYPE, ...) \
enum class TYPE {__VA_ARGS__};\
struct Helper_ ## TYPE { \
static const String& toName(TYPE type) {\
int index = static_cast<int>(type);\
return splitStringVec()[index];}\
static const TYPE toType(const String& name){\
static std::unordered_map<String,TYPE> typeNameMap;\
if( typeNameMap.empty() )\
{\
const StringVector& ssVec = splitStringVec();\
for (size_t i = 0; i < ssVec.size(); ++i)\
typeNameMap.insert(std::make_pair(ssVec[i], static_cast<TYPE>(i)));\
}\
return typeNameMap[name];}\
static const StringVector& splitStringVec() {\
static StringVector typeNameVector;\
if(typeNameVector.empty()) \
{\
typeNameVector = StringUtil::split(#__VA_ARGS__, ",");\
for (auto& name : typeNameVector)\
{\
name.erase(std::remove(name.begin(), name.end(), ' '),name.end()); \
name = String(#TYPE) + "::" + name;\
}\
}\
return typeNameVector;\
}\
};
using String = std::string;
using StringVector = std::vector<String>;
StringVector StringUtil::split( const String& str, const String& delims, unsigned int maxSplits, bool preserveDelims)
{
StringVector ret;
// Pre-allocate some space for performance
ret.reserve(maxSplits ? maxSplits+1 : 10); // 10 is guessed capacity for most case
unsigned int numSplits = 0;
// Use STL methods
size_t start, pos;
start = 0;
do
{
pos = str.find_first_of(delims, start);
if (pos == start)
{
// Do nothing
start = pos + 1;
}
else if (pos == String::npos || (maxSplits && numSplits == maxSplits))
{
// Copy the rest of the string
ret.Push_back( str.substr(start) );
break;
}
else
{
// Copy up to delimiter
ret.Push_back( str.substr(start, pos - start) );
if(preserveDelims)
{
// Sometimes there could be more than one delimiter in a row.
// Loop until we don't find any more delims
size_t delimStart = pos, delimPos;
delimPos = str.find_first_not_of(delims, delimStart);
if (delimPos == String::npos)
{
// Copy the rest of the string
ret.Push_back( str.substr(delimStart) );
}
else
{
ret.Push_back( str.substr(delimStart, delimPos - delimStart) );
}
}
start = pos + 1;
}
// parse up to next real data
start = str.find_first_not_of(delims, start);
++numSplits;
} while (pos != String::npos);
return ret;
}
exemple
ENUM_MAKE(MY_TEST, MY_1, MY_2, MY_3)
MY_TEST s1 = MY_TEST::MY_1;
MY_TEST s2 = MY_TEST::MY_2;
MY_TEST s3 = MY_TEST::MY_3;
String z1 = Helper_MY_TEST::toName(s1);
String z2 = Helper_MY_TEST::toName(s2);
String z3 = Helper_MY_TEST::toName(s3);
MY_TEST q1 = Helper_MY_TEST::toType(z1);
MY_TEST q2 = Helper_MY_TEST::toType(z2);
MY_TEST q3 = Helper_MY_TEST::toType(z3);
automatiquement, les macros ENUM_MAKE génèrent des "classes enum" et des classes d'assistance avec "fonction de réflexion enum".
Afin de réduire les erreurs, tout est défini à la fois avec un seul ENUM_MAKE.
L’avantage de ce code est automatiquement créé pour permettre une réflexion et une analyse approfondie du code macro, un code facile à comprendre. 'enum to string', la performance 'string to enum' est à la fois l'algorithme O (1).
Les inconvénients sont lors de la première utilisation, la classe auxiliaire pour le vecteur chaîne et la carte enum relection est initialisée . Mais si vous le souhaitez, vous serez également pré-initialisé. -