Qui Typesafe Enum en C++ Utilisez-Vous?

Un bon compromis méthode est: est-ce

struct Flintstones {
   enum E {
      Fred,
      Barney,
      Wilma
   };
};

Flintstones::E fred = Flintstones::Fred;
Flintstones::E barney = Flintstones::Barney;

Ce n'est pas typesafe dans le même sens que votre version est, mais l'usage en est plus agréable que la norme des enums, et vous pouvez toujours profiter de conversion d'entier quand vous en avez besoin.

Je n'ai pas. Beaucoup trop généraux pour peu d'avantages. Aussi, le fait de pouvoir à la caste des énumérations à différents types de données pour la sérialisation est un outil très pratique. Je n'ai jamais vu un cas où un "Type de sécurité" de l'énumération serait la valeur de la surcharge et de la complexité où C++ offre une assez bonne mise en œuvre déjà.

Je suis personnellement en utilisant une version adaptée de la typesafe enum idiome. Il ne fournit pas tous les cinq "exigences" que vous avez indiqué dans votre modifier, mais je suis en total désaccord avec certains d'entre eux de toute façon. Par exemple, je ne vois pas comment Prio#4 (conversion des valeurs de chaînes de caractères) n'a rien à voir avec le type de sécurité. La plupart du temps, représentation de chaîne de valeurs individuelles doit être distincte de la définition du type, de toute façon (pense i18n pour une simple raison pourquoi). Priorité n ° 5 (iteratio, qui est facultatif) est l'une des plus belles choses que j'aimerais voir naturellement qui se passe dans les énumérations, de sorte que je me sentais triste qu'il apparaît comme "facultatif" dans votre demande, mais il semble que c'est mieux traitée par le biais d'un séparer itération du système d' comme begin/end fonctions ou un enum_iterator, qui fait d'eux de travailler de façon transparente avec STL et C++11 foreach.

Otoh, que cette simple idiome bien fournit Priorité N ° 3 Priorité n ° 1 grâce au fait que la plupart du temps que des enveloppements enums avec plus d'informations de type. Sans oublier qu'il est une solution très simple qui, pour la plupart, ne nécessite aucune dépendance externe en-têtes, il est donc assez facile à transporter. Il a aussi l'avantage de faire des énumérations de portée à la C++11:

//This doesn't compile, and if it did it wouldn't work anyway
enum colors { salmon, .... };
enum fishes { salmon, .... };

//This, however, works seamlessly.
struct colors_def { enum type { salmon, .... }; };
struct fishes_def { enum type { salmon, .... }; };

typedef typesafe_enum<colors_def> colors;
typedef typesafe_enum<fishes_def> fishes;

Le seul "trou" cette solution fournit, c'est qu'il ne traite pas le fait que cela ne les empêche pas enums de différents types (ou un enum et un int) d'être directement comparés, parce que lorsque vous utilisez des valeurs directement vous forcer la conversion implicite en int:

if (colors::salmon == fishes::salmon) { .../* Ooops! */... }

Mais jusqu'à présent, j'ai trouvé ces problèmes peuvent être résolus simplement en offrant une meilleure comparaison pour le compilateur, par exemple, explicitement, en fournissant un opérateur qui compare deux différents enum types, puis en les forçant à s'échouer:

//I'm using backports of C++11 utilities like static_assert and enable_if
template <typename Enum1, typename Enum2>
typename enable_if< (is_enum<Enum1>::value && is_enum<Enum2>::value) && (false == is_same<Enum1,Enum2>::value) , bool >
::type operator== (Enum1, Enum2) {
    static_assert (false, "Comparing enumerations of different types!");
}

Bien qu'il ne semble pas casser le code jusqu'à présent, et il ne explicitement traiter le problème spécifique sans faire autre chose, je ne suis pas certain que telle chose est une chose que l'on "devrait" faire (je le soupçonne d'interférer avec enums prend déjà part à des opérateurs de conversion déclaré ailleurs; je serais heureux de recevoir vos commentaires à ce sujet).

La combinant avec la au-dessus de typesafe idiome donne quelque chose qui est relativement proche du C++11 enum class dans humanibility (la lisibilité et la maintenabilité) sans avoir à faire quelque chose de trop obscur. Et je dois avouer que c'était amusant à faire, je n'avais jamais pensé à fait demander le compilateur si j'avais à faire avec enums ou pas...

J'ai donné une réponse à cette ici, sur un thème différent. C'est un style différent de l'approche qui permet à la plupart des mêmes fonctionnalités sans nécessiter de modification de l'original enum définition (et, par conséquent, permettant l'utilisation dans le cas où vous ne définissez pas l'enum). Il permet également d'exécution le contrôle de la portée.

L'inconvénient de cette approche est qu'il n'est pas par programmation appliquer le couplage entre l'enum et de la classe d'aide, de sorte qu'ils doivent être mis à jour en parallèle. Il fonctionne pour moi, mais YMMV.

Utilisation boost::variant!

Après avoir essayé beaucoup de les idées ci-dessus et de leur trouver un défaut, je suis tombé sur cette approche simple:

#include <iostream>
#include <boost/variant.hpp>
struct A_t {};
static const A_t A = A_t();
template <typename T>
bool isA(const T & x) { if(boost::get<A_t>(&x)) return true; return false; }
struct B_t {};
static const B_t B = B_t();
template <typename T>
bool isB(const T & x) { if(boost::get<B_t>(&x)) return true; return false; }
struct C_t {};
static const C_t C = C_t();
template <typename T>
bool isC(const T & x) { if(boost::get<C_t>(&x)) return true; return false; }
typedef boost::variant<A_t, B_t> AB;
typedef boost::variant<B_t, C_t> BC;
void ab(const AB & e)
{
if(isA(e))
std::cerr << "A!" << std::endl;
if(isB(e))
std::cerr << "B!" << std::endl;
//ERROR:
//if(isC(e))
//  std::cerr << "C!" << std::endl;
//ERROR:
//if(e == 0)
//  std::cerr << "B!" << std::endl;
}
void bc(const BC & e)
{
//ERROR:
//if(isA(e))
//  std::cerr << "A!" << std::endl;
if(isB(e))
std::cerr << "B!" << std::endl;
if(isC(e))
std::cerr << "C!" << std::endl;
}
int main() {
AB a;
a = A;
AB b;
b = B;
ab(a);
ab(b);
ab(A);
ab(B);
//ab(C); //ERROR
//bc(A); //ERROR
bc(B);
bc(C);
}

Vous pouvez probablement venir avec une macro pour générer le code. (Laissez-moi savoir si vous faites).

Contrairement à d'autres approches celui-ci est en fait de type sécurisé et fonctionne avec des vieux C++. Vous pouvez même les faire refroidir types comme boost::variant<int, A_t, B_t, boost::none>, par exemple, pour représenter une valeur qui pourrait être Un, B, entier ou rien de ce qui est presque Haskell98 les niveaux de sécurité de type.

Inconvénients d'être conscient de:

• au-moins avec de vieux coup de pouce-je suis sur un système de boost 1.33 -- vous êtes limité à 20 éléments dans votre variante; il y a un travail autour, cependant
• affecte moment de la compilation
• fou des messages d'erreur, mais c'est du C++ pour vous

Mise à jour

Ici, pour votre commodité, votre typesafe-enum "bibliothèque". Collez cet en-tête:

#ifndef _TYPESAFE_ENUMS_H
#define _TYPESAFE_ENUMS_H
#include <string>
#include <boost/variant.hpp>
#define ITEM(NAME, VAL) \
struct NAME##_t { \
std::string toStr() const { return std::string( #NAME ); } \
int toInt() const { return VAL; } \
}; \
static const NAME##_t NAME = NAME##_t(); \
template <typename T> \
bool is##NAME(const T & x) { if(boost::get<NAME##_t>(&x)) return true; return false; } \
class toStr_visitor: public boost::static_visitor<std::string> {
public:
template<typename T>
std::string operator()(const T & a) const {
return a.toStr();
}
};
template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
std::string toStr(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
return boost::apply_visitor(toStr_visitor(), a);
}
class toInt_visitor: public boost::static_visitor<int> {
public:
template<typename T>
int operator()(const T & a) const {
return a.toInt();
}
};
template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
int toInt(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
return boost::apply_visitor(toInt_visitor(), a);
}
#define ENUM(...) \
typedef boost::variant<__VA_ARGS__>
#endif

Et de l'utiliser comme:

ITEM(A, 0);
ITEM(B, 1);
ITEM(C, 2);
ENUM(A_t, B_t) AB;
ENUM(B_t, C_t) BC;

Avis que vous avez à dire A_t au lieu de A dans le ENUM macro qui détruit une partie de la magie. Oh bien. Aussi, notez qu'il y a maintenant un toStr fonction et un toInt fonction pour répondre OPs exigence de la simple conversion de chaînes et de services de renseignements. L'exigence je ne peux pas comprendre est une façon d'itérer sur les éléments. Laissez-moi savoir si vous savez comment écrire une telle chose.