Applying a rule on how to increment an enum - c++

Question

Is there a way to change how an enum sets the values of its constants? Normally it's incrementing by one but I want to apply an other rule. In PAWN this would work
enum (<<=1) {
a = 1,//0b001
b,//0b010
c//0b100
}
Is there a way to do this in C++?

Answer 1

not automatically, but you can specify manually each value
enum X {
a = 0x01,
b = 0x02,
c = 0x04
};

Answer 2

You could automate this shifting process using templates metaprogramming:
template<int by>
struct OneShlBy {
enum { Value = OneShlBy<by - 1>::Value << 1 };
};
template<>
struct OneShlBy<0> {
enum { Value = 1 };
};
enum X {
a = OneShlBy<0>::Value,
b = OneShlBy<1>::Value,
c = OneShlBy<2>::Value
};

Answer 3

One way, assuming C++11, would be
constexpr int func(int x)
{
return x << 1;
}
enum X
{
a = 1,
b = func(a),
c = func(b)
};
The func() can then be used to implement any relationship you like between consecutive named values.
Before C++11, alternatives might include
enum X
{
a = 1,
b = a << 1,
c = b << 1
};
or (with a macro)
#define func(x) x << 1
enum X
{
a = 1,
b = func(a),
c = func(b)
};
#undef func

Answer 4

One common approach for the particular example you give (enums which are essentially flags within a word) is to use two enums, one for the bit index and a second enum for the actual bit values:
enum {
b_a, // 0
b_b, // 1
b_c, // 2
b_d, // 3
};
enum {
a = 1 << b_a, // 1
b = 1 << b_b, // 2
c = 1 << b_c // 4
d = 1 << b_d // 8
};
It's not ideal, I know, but it avoids explicit literal constants. Some of the nastiness can be hidden with macros, which you may or may not consider a good thing to do.

Answer 5

What you were doing works perfectly fine:
#include <iostream>
enum x {
a = 0b001
, b = 0b010
, c = 0b100
};
int main()
{
std::cout << x::a << '\n';
std::cout << x::b << '\n';
std::cout << x::c << '\n';
}
Note: this is only standard in C++14 where binary literals are introduced.
Otherwise you can use the shift operator to specify the bit position:
enum x {
a = 1 << 0
, b = 1 << 1
, c = 1 << 2
};
Another possibility if you are looking to save some maintenance work is defining each enum in terms of previously defined enums:
enum x {
a = 1
, b = a << 1
, c = b << 1
, d = c << 1
, e = d << 1
};
This means you can add an element in the middle relatively painlessly:
enum x {
a = 1
, b = a << 1
, z = b << 1 // new element added
, c = z << 1 // only need to adjust one other
, d = c << 1
, e = d << 1
};

Answer 6

Stealing the great idea of Rob, there's a way to specify how to increment the value of an enum, this it isn't very automatic though, but as long as your enum have always the same fields you can do something like this:
template <typename T, T(*INC)(const T), T start = {}>
struct managed_enum
{
enum
{
a = start,
b = INC(a),
c = INC(b),
};
};
With this template you could do the following:
template<typename T>
constexpr T shift_left(const T value) { return value << 1; }
using shifted = managed_enum<int, shift_left<int>, 1>;
Which results on the enum you're looking for (see here). Well, shifted isnt an enum but a struct, hope it doesn't matters.
Defining different increment functions, you can have different families of enums automatically increased, as long as all of them have only the three values of managed_enum (a, b, c):
template<typename T>
constexpr T shift_left(const T value) { return value << 1; }
template<typename T>
constexpr T increment(const T value) { return value + 1; }
template<typename T>
constexpr T bicrement(const T value) { return value + 2; }
using shifted = managed_enum<int, shift_left<int>, 1>;
using increment = managed_enum<int, increment<int>>;
using bicrement = managed_enum<int, bicrement<int>>;