44

Following the discussion in question Incrementation and decrementation of “enum class”, I'd like to ask about the possible implementation of arithmetic operators for enum class types.

Example from the original question:

enum class Colors { Black, Blue, White, END_OF_LIST };

// Special behavior for ++Colors
Colors& operator++( Colors &c ) {
  c = static_cast<Colors>( static_cast<int>(c) + 1 );
  if ( c == Colors::END_OF_LIST )
    c = Colors::Black;
  return c;
}

Is there a way to implement arithmetic operators without casting to a type with already defined operators? I can't think of any, but casting bothers me. Casts are usually indication of something wrong and there has to be a very good reason for their usage. I would expect the language to allow implementation of an operator to be achievable without forcing to a specific type.

Update Dec 2018: One of the papers towards C++17 seems to address this at least partially by allowing conversions between enum class variable and the underlying type: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0138r2.pdf

Improve this question
18
  • 17
    "Casts are usually indication of something wrong" ... casts are there to be used. And it's sometimes better to explicitly cast than to let the compiler assume whatever it wants. Commented Mar 16, 2013 at 16:08
  • 8
    @icepack: You're the one who doesn't want to do the simple and obvious cast. You're the one who thinks that having to cast in certain limited circumstances is a language deficiency. So you're the one who's going to have to live with the consequences of that. Commented Mar 16, 2013 at 16:53
  • 9
    @icepack: "I don't see a reason to provide an integral construct in the language without an integral set of valid operations on it" If you wanted those constructs, you shouldn't be using an enum class. The entire purpose of this is to not be implicitly convertible to an integer. It's to not treat it as an integer type. Therefore, if you want to perform certain integer operations on it, you must define them yourself. Commented Mar 16, 2013 at 16:59
  • 4
    @icepack: "But it will bite off in the future." No, it won't; that's dogmatic thinking. You're only doing a cast in certain, specific and isolated locations. Commented Mar 16, 2013 at 17:01
  • 5
    "by using casts I can diminish all the advantages of enum class back to the original enum" -- no. The advantage of enum class is that it does not implicitly convert to an integral type, not that it cannot be converted to an integral type. When you want to treat a given enum class like an integral type, you are able to do so, and can explicitly do so inside your enum class interface. Yes, adding iteration-over-elements and the like support in-language would be a fine thing, but enum class was added because it was both useful and easy. Commented Mar 16, 2013 at 17:24

3 Answers 3

Reset to default
44

The no-cast solution is to use switch. However, you can generate a pseudo-switch using templates. The principle is to recursively process all values of the enum using a template list (or a parameter pack). So, here are 3 methods I found.

Test enum:

enum class Fruit
{
    apple,
    banana,
    orange,
    pineapple,
    lemon
};

The vanilla switch (live here):

Fruit& operator++(Fruit& f)
{
    switch(f)
    {
        case Fruit::apple:     return f = Fruit::banana;
        case Fruit::banana:    return f = Fruit::orange;
        case Fruit::orange:    return f = Fruit::pineapple;
        case Fruit::pineapple: return f = Fruit::lemon;
        case Fruit::lemon:     return f = Fruit::apple;
    }
}

The C++03-ish method (live here):

template<typename E, E v>
struct EnumValue
{
    static const E value = v;
};

template<typename h, typename t>
struct StaticList
{
    typedef h head;
    typedef t tail;
};

template<typename list, typename first>
struct CyclicHead
{
    typedef typename list::head item;
};

template<typename first>
struct CyclicHead<void,first>
{
    typedef first item;
};

template<typename E, typename list, typename first = typename list::head>
struct Advance
{
    typedef typename list::head lh;
    typedef typename list::tail lt;
    typedef typename CyclicHead<lt, first>::item next;

    static void advance(E& value)
    {
        if(value == lh::value)
            value = next::value;
        else
            Advance<E, typename list::tail, first>::advance(value);
    }
};

template<typename E, typename f>
struct Advance<E,void,f>
{
    static void advance(E& value)
    {
    }
};

/// Scalable way, C++03-ish
typedef StaticList<EnumValue<Fruit,Fruit::apple>,
        StaticList<EnumValue<Fruit,Fruit::banana>,
        StaticList<EnumValue<Fruit,Fruit::orange>,
        StaticList<EnumValue<Fruit,Fruit::pineapple>,
        StaticList<EnumValue<Fruit,Fruit::lemon>,
        void
> > > > > Fruit_values;

Fruit& operator++(Fruit& f)
{
    Advance<Fruit, Fruit_values>::advance(f);
    return f;
}

The C++11-ish method (live here):

template<typename E, E first, E head>
void advanceEnum(E& v)
{
    if(v == head)
        v = first;
}

template<typename E, E first, E head, E next, E... tail>
void advanceEnum(E& v)
{
    if(v == head)
        v = next;
    else
        advanceEnum<E,first,next,tail...>(v);
}

template<typename E, E first, E... values>
struct EnumValues
{
    static void advance(E& v)
    {
        advanceEnum<E, first, first, values...>(v);
    }
};

/// Scalable way, C++11-ish
typedef EnumValues<Fruit,
        Fruit::apple,
        Fruit::banana,
        Fruit::orange,
        Fruit::pineapple,
        Fruit::lemon
> Fruit_values11;

Fruit& operator++(Fruit& f)
{
    Fruit_values11::advance(f);
    return f;
}

(C++11-ish old version)

You may be able to extend by adding some preprocessor to remove the need to repeat the list of values.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Very nice indeed! For sure, need of such stuff doesn't make the life of a developer easier. Sounds natural to me that such an infrastructure was built in the C++11 standard natively.
I like the templates version because you can use them for more than just increment operator : you can add names, etc... The C++03-ish method is for compiler not supporting variadic templates, and can be adapted for simple enums (for C++03-only compilers). Also, I made the C++1-ish method less verbose.
7

Every operator in C++ on enums can be written without casting to an underlying type, but the result would be ridiculously verbose.

As an example:

size_t index( Colors c ) {
  switch(c) {
    case Colors::Black: return 0;
    case Colors::Blue: return 1;
    case Colors::White: return 2;
  }
}
Color indexd_color( size_t n ) {
  switch(n%3) {
    case 0: return Colors::Black;
    case 1: return Colors::Blue;
    case 2: return Colors::White;
  }
}
Colors increment( Colors c, size_t n = 1 ) {
  return indexed_color( index(c) + n );
}
Colors decrement( Colors c, size_t n = 1 ) {
  return indexed_color( index(c)+3 - (n%3) );
}
Colors& operator++( Colors& c ) {
  c = increment(c)
  return c;
}
Colors operator++( Colors& c, bool ) {
  Colors retval = c;
  c = increment(c)
  return retval;
}

and a smart compiler will be able to turn these into operations that are directly on the base integral type.

But casting to a base integral type in the interface of your enum class is not a bad thing. And operators are part of the interface for your enum class.

If you don't like that loop through size_t and consider it a fake cast, you can just write:

Colors increment( Colors c ) {
  switch(c) {
    case Colors::Black: return Colors::Blue;
    case Colors::Blue: return Colors::White;
    case Colors::White: return Colors::Black;
  }
}

and similarly for decrement, and implement increment-by-n as loops of repeated increment.

Improve this answer

12 Comments

That's the best I can think of as well, but as you said "it's ridiculously verbose", and even more important - not scalable.
@SomeWittyUsername: enum class was created precisely for the reason to make it impossible (to do accidentally; so it requires a ludicruous amount of hoop-jumping to do on purpose). If this protective mechanism stands in your way, simply don't use enum class, just old enum.
you can use the following code to cast the enums in a safe way: melpon.org/wandbox/permlink/8eJuKbrjem8q8srL
@jan are you certain? If the underlying type value is 'out of gamut', is it legal to cast to enum? Might be worth a SO question.
@JanChristophUhde No, I'm worried about gamut. I'm aware that enums guarantee values in the "bit gamut" of their values as valid. I'm uncertain if they guarantee that all values in the underlying type can be converted to values of the enum in a defined way. (I get that the naive implementation of enums seemingly makes this "of course it would work"; I'm asking if you are aware if the standard supports that assumption.)
|
1 
enum class Colors { Black, Blue, White };

Colors operator++(Colors& color)
{
    color = (color == Colors::White) ? Colors::Black : Colors(int(color) + 1);
    return color;
}

Check in C++ Shell

Improve this answer

1 Comment

This starts to cause issues as soon as some enum values have explicit values. See for example cpp.sh/6pa7t

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.