Overloading the '++' operator for a scoped enum class type

Question

I've been experimenting with the enum class feature of C++ and successfully got the ++ operator to overload as follows:

enum class counter_t : uint8_t {VAL1 = 0, VAL2, VAL3, VAL4, END};

inline counter_t operator ++ (counter_t c, int) {
  counter_t c2;
  if (c == counter_t::END) {
    c2 = counter_t::VAL1;
  }
  else {
    c2 = (counter_t)((uint8_t)c + 1);
  }
  return (c2);
}

int main(void) {

  volatile counter_t x = counter_t::VAL1;
  x = x++;
  x++;

  while(1) {
    // Do stuff
  }
}

It is fairly straightforward. The "x=x++;" line works fine, however the "x++;" line does not. What is the correct form of the ++ operator function for the autoincrement version?

Umm... the ++ operator only takes one operand, doesn't it? Why do you have counter_t and int? — Jashaszun
– Jashaszun, Commented Jul 28, 2015 at 16:09
@Jashaszun It depends, prefix increment does not take an extra argument, but the postfix operator takes an extra dummy int argument, so it have a different function signature from the prefix operator. — Some programmer dude
– Some programmer dude, Commented Jul 28, 2015 at 16:13
Isn't x = x++; still undefined, even if operator++ is overloaded? — jxh
– jxh, Commented Jul 28, 2015 at 16:29
@jxh Nope, it's valid to write x = operator++(x,0); and therefore valid to write x = x++;. Function calls have more sequencing restraints than built-in operators. — aschepler
– aschepler, Commented Jul 28, 2015 at 16:39

score 4 · Accepted Answer · 2015-07-28 17:21:24Z

4

You may use this to implement a prefix increment:

inline counter_t& operator ++ (counter_t& c) {
  if (c == counter_t::END)
      c = counter_t::VAL1;
  else
      c = counter_t(unsigned(c) + 1);
  return c;
}

Now, you can use the prefix increment to implement the postfix increment:

inline counter_t operator ++ (counter_t& c, int) {
  counter_t result = c;
  ++c;
  return result;
}

Test:

#include <iostream>
int main(void) {
    counter_t prefix = counter_t::VAL1;
    for(unsigned i = 0; i < 5; ++i)
        std::cout << unsigned(++prefix) << ' ';
    std::cout << '\n';

    counter_t postfix = counter_t::VAL1;
    for(unsigned i = 0; i < 5; ++i)
        std::cout << unsigned(postfix++) << ' ';
    std::cout << '\n';
}

Note: In each case the counter is taken by reference and gets modified.

edited Jul 28, 2015 at 17:21

answered Jul 28, 2015 at 17:02

user2249683

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

Comments

Peter Mortensen · Accepted Answer · 2024-03-09 18:54:07Z

3

Just following the errors, the following code compiles runs and works fine on MSVC. Note the volatile and & in function parameters. Also c2 = c and a couple of modifications, to follow the ++ standard (return value, then increment). volatile is necessary only because you have x declared as volatile.

inline counter_t operator ++ (volatile counter_t &c, int)
{
    counter_t c2;

    if (c == counter_t::END)
        c2 = counter_t::VAL1;
    else
        c2 = static_cast<counter_t>(static_cast<uint8_t>(c) + 1);

    c = c2;

    return c2;
}

edited Mar 9, 2024 at 18:54

Peter Mortensen

31.4k22 gold badges110 silver badges134 bronze badges

answered Jul 28, 2015 at 16:23

Jaka Konda

1,4363 gold badges17 silver badges36 bronze badges

5 Comments

Jarod42 Over a year ago

You fail to follow standards with x++. it should be {auto old = c; ++c; return old;} and use your function for ++x.

Paul Blase Over a year ago

The volatile was in there to keep the compiler from optimizing the program to nothing (even at -O1). I turned it down to no optimization, and don't need the volatile.

Paul Blase Over a year ago

Hey, that works!. I thought that the pass-by-reference should be in there somewhere, but didn't know about the static_cast. Thank you very much.

Jaka Konda Over a year ago

static_cast isn't important in this case. I bothered me because I had it underlined in VS as an warning "C style cast instead of C++". Try to avoid C style cast, they can be problematic sometimes.

BЈовић May 6 at 16:06

hmmm it doesn't look like you know what volatile is for :(

Collectives™ on Stack Overflow

Overloading the '++' operator for a scoped enum class type

2 Answers 2

Comments

5 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

5 Comments

Your Answer

Sign up or log in

Post as a guest

Related