Better Enums

Reflective compile-time C++ enum library with clean syntax, in a single header file. For example:

#include <enum.h>
ENUM(Channel, uint8_t, Red = 1, Green, Blue)

defines a type Channel. You can then do natural things such as:

Channel channel = Channel::Green;

channel._to_string();           // Results in the string "Green"
Channel::_from_string("Red");   // Results in Channel::Red

Channel::_from_integral(3);     // Checked cast, Channel::Blue

Channel::_size;                 // Number of channels (3)
Channel::_values()[0];          // Get the first channel

for (Channel channel : Channel::_values()) {
    process(channel);           // Iterate over all channels
}

// Natural switch, compiler checks the cases
switch (channel) {
    case Channel::Red:   break;
    case Channel::Green: break;
    case Channel::Blue:  break;
}

...and more.

In C++11, everything is available at compile time. You can convert your enums, loop over them, find their max, statically enforce conventions, and pass along the results as template arguments or to constexpr functions. All the reflection is available for your metaprogramming needs.

The interface is the same for C++98 — you just have to use most of it at run time only. This library does provide scoped and sized enums, something not built into C++98.

See the project page for full documentation and here for a simple working program.

Installation

Simply add enum.h to your project — that's it.

Then, include it and use the ENUM macro. Your compiler will generate the rich enums that are missing from standard C++.

Additional features

• No dependencies and no external build tools. Uses only standard C++, though, for C++98, variadic macro support is required.
• Supported and tested on clang, gcc, and msvc.
• Fast compilation. You have to declare a few dozen enums to slow down your compiler as much as just including iostream does.
• Use any initializers and sparse ranges, just like with a built-in enum.
• Guaranteed size and alignment — you choose the representation type.

Limitations

The biggest current limitation is that the ENUM macro can't be used inside a class. This seems difficult to remove, but I am looking into it. In the meantime, there is a workaround with a typedef (or using):

ENUM(UniquePrefix_Color, uint8_t, Red, Green, Blue)

struct triplet {
    typedef UniquePrefix_Color      Color;
    Color                           r, g, b;
};

triplet::Color  color;

You can, however, use ENUM inside a namespace.

Contact

Don't hesitate to contact me about features or bugs: antonbachin@yahoo.com, Twitter @better_enums, or open an issue on GitHub.

License and history

Better Enums is released under the BSD 2-clause license. See LICENSE.

The library was originally developed by the author in the winter of 2012-2013 at Hudson River Trading, as a replacement for an older generator called BETTER_ENUM.