Which Typesafe Enum in C++ Are You Using?

A nice compromise method is this:

struct Flintstones { enum E { Fred, Barney, Wilma }; }; Flintstones::E fred = Flintstones::Fred; Flintstones::E barney = Flintstones::Barney; 

It's not typesafe in the same sense that your version is, but the usage is nicer than standard enums, and you can still take advantage of integer conversion when you need it.

I use C++0x typesafe enums. I use some helper template/macros that provide the to/from string functionality.

enum class Result { Ok, Cancel}; 

I don't. Way too much overhead for little benefit. Also, being able to caste enumerations to different data types for serialization is a very handy tool. I have never seen an instance where a "Type safe" enumeration would be worth the overhead and complexity where C++ offers a good enough implementation already.

My take is that you're inventing a problem and then fitting a solution onto it. I see no need to do an elaborate framework for an enumeration of values. If you are dedicated to having your values only be members of a certain set, you could hack up a variant of a unique set datatype.

I'm personally using an adapted version of the typesafe enum idiom. It doesn't provide all the five "requirements" that you've stated in your edit, but I strongly disagree with some of them anyway. For example, I don't see how Prio#4 (conversion of values to strings) has anything to do with type safety. Most of the time string representation of individual values should be separate from the definition of the type anyway (think i18n for a simple reason why). Prio#5 (iteratio, which is optional) is one of the nicest things I'd like to see naturally happening in enums, so I felt sad that it appears as "optional" in your request, but it seems it is better addressed via a separate iteration system such as begin/end functions or an enum_iterator, which makes them work seamlessly with STL and C++11 foreach.

OTOH this simple idiom nicely provides Prio#3 Prio#1 thanks to the fact that it mostly only wraps enums with more type information. Not to mention it is a very simple solution that for the most part doesn't require any external dependency headers, so it's pretty easy to carry around. It also has the advantage of making enumerations scoped a-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; 

The only "hole" that solution provides is that it doesn't address the fact that it doesn't prevent enums of different types (or an enum and an int) from being directly compared, because when you use values directly you force the implicit conversion to int:

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

But so far I've found such problems can be solved by simply offering a better comparison to the compiler - for example, explicitly providing an operator that compares any two different enum types, then forcing it to fail:

// 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!"); } 

Though it doesn't seem to break code so far, and it does to explicitly deal with the specific problem without doing something else, I'm not sure it such thing is a thing one "should" do (I suspect it will interfere with enums already taking part in conversion operators declared elsewhere; I'd gladly receive commentary about this).

Combining this with the above typesafe idiom gives something that is relatively close to C++11 enum class in humanibility (readability and maintainability) without having to do anything too obscure. And I have to admit it was fun to do, I had never thought to actually ask the compiler if I was dealing with enums or not...

I think the Java enum would be a good model to follow. Essentially, the Java form would look like this:

public enum Result { OK("OK"), CANCEL("Cancel"); private final String name; Result(String name) { this.name = name; } public String getName() { return name; } } 

What's interesting about the Java approach is that OK and CANCEL are immutable, singleton instances of Result (with the methods that you see). You cannot create any further instances of Result. Since they're singletons, you can compare by pointer/reference---very handy. :-)

ETA: In Java, instead of doing bitmasks by hand, instead you use an EnumSet to specify a bit set (it implements the Set interface, and works like sets---but implemented using bitmasks). Much more readable than hand-written bitmask manipulation!

I gave an answer to this here, on a different topic. It's a different style of approach which allows most of the same functionality without requiring modification to the original enum definition (and consequently allowing usage in cases where you don't define the enum). It also allows runtime range checking.

The downside of my approach is that it doesn't programmatically enforce the coupling between the enum and the helper class, so they have to be updated in parallel. It works for me, but YMMV.

I am currently writing my own typesafe enum library at https://bitbucket.org/chopsii/typesafe-enums

I am not the most experienced C++ developer ever, but I am writing this due to the shortcomings of the BOOST vault enums.

Feel free to check it out and use them yourself, but they have some (hopefully minor) usability issues, and are probably not at all cross-platform.

Please contribute if you want to. This is my first open source undertaking.

Use boost::variant!

After trying a lot of the above ideas and finding them lacking I hit upon this simple approach:

#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); } 

You can probably come up with a macro to generate the boilerplate. (Let me know if you do.)

Unlike other approaches this one is actually type-safe and works with old C++. You can even make cool types like boost::variant<int, A_t, B_t, boost::none>, for example, to represent a value that could be A, B, an integer or nothing which is almost Haskell98 levels of type safety.

Downsides to be aware of:

• at-least with old boost -- I'm on a system with boost 1.33 -- you are limited to 20 items in your variant; there is a work-around however
• affects compile time
• insane error messages -- but that's C++ for you

Update

Here, for your convenience is your typesafe-enum "library". Paste this header:

#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 

And use it like:

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

Notice you have to say A_t instead of A in the ENUM macro which destroys some of the magic. Oh well. Also, notice there's now a toStr function and a toInt function to meet OPs requirement of simple conversion to strings and ints. The requirement I can't figure out is a way to iterate over the items. Let me know if you know how to write such a thing.

Not sure if this post is too late, but there's an article on GameDev.net which satisfies all but the 5th point (ability to iterate over enumerators): http://www.gamedev.net/reference/snippets/features/cppstringizing/

The method described by the article allows string conversion support for existing enumerations without changing their code. If you only want support for new enumerations though, I'd go with Boost.Enum (mentioned above).