Boost logo

Boost :

Subject: [boost] [enums] Interest in an alternative emulation of scoped enums classes
From: Vicente Botet (vicente.botet_at_[hidden])
Date: 2011-02-27 15:45:51


I have been working in an alternative implementation of the Beman's Scoped
enums macros
Daniel James proposed.

The macros are very similar

BOOST_ENUM_CLASS_START(algae, uint8) {
  green, red, cyan
} BOOST_ENUM_CLASS_END(algae, uint8)

algae sample( algae::red );
void func(algae);

The major advantages are:

* No need to use a macro to name the type in most of the cases
* The type is not implicitly convertible to the underlying type neither to
bool and so it is closer the intended goal of strongly enums.
* Allows to state explicitly the underlying type

The major liabilities are:

* In some context we can not use the enum class. This is the case of switch
statements and template parameters. In order to get the native enum value a
free function enums::get_value allows to workaround that in a portable way.

    algae v;
    switch (boost::enums::get_value(v))
    case algae ::green: return("EnumClass::Default");
    case algae ::red: return("EnumClass::Enum1");
    case algae ::cyan :

* the emulation is not an enum, that is is_enum(algae)::value is false

The user can use


or the library could provide an is_enum nested on the enums namespace.


or we can specialize boost::is_enum<EC>

For template parameters the meta-function enum_type gives the type of the
native enum used by the emulation.

  template <enums::enum_type<algae>::type V>
  struct ex;

* Use in union
The emulation providing constructors (which is optional) can not be used in
unions if the compiler doesn't allows class with constructors in unions.

* default value
There is no portable way to manage with standard *implicit* default values
if the enum class emulation can not define constructors.
I have found an explicit way that allows to assign the default value. Use
This function will be equivalent to EC() if enum class is supported by the

    algae e(enums::default_value<algae>());

* Explicit conversion from int
There is no portable way to manage with standard *explicit* conversion of
ints if the enum class emulation can not define constructors. I have found
an explicit way that allows to manage with explicit conversion using a
function convert_to<EC>(v) instead of the Constructor. This function will be
equivalent to EC(v) if enum class is supported

  algae e(convert_to<algae>(1));

There is not too much documentation yet. You can find the code and some test
in the sandbox

I could provide alternative macros for users considering a better approach

* PP Sequence Syntax
BOOST_ENUM_CLASS(EnumClass, Underlying,
     ( (Enum0) (0) )
     ( (Enum1) )
     ( (Enum2) )

PP Variadic Syntax
BOOST_ENUM_CLASS(EnumClass, Underlying,
     (Enum0) (0),

With the macros the meta-functions and the functions we can write portable
code using strongly scoped enums. Is there any interest for this in Boost?

Comments or suggestions appreciated,

P.S. the convert_to function is the one of Boost.Conversion.

View this message in context:
Sent from the Boost - Dev mailing list archive at

Boost list run by bdawes at, gregod at, cpdaniel at, john at