应用关于如何递增枚举的规则

Question

有没有办法改变枚举如何设置其常量的值？通常它会递增1，但我想要应用其他规则。典当这会工作

enum (<<=1) { 
a = 1,//0b001 
b,//0b010 
c//0b100 
} 

有没有办法在C++中做到这一点？

Answer 1

不会自动的，但也可以手动指定每个值

enum X { 
    a = 0x01, 
    b = 0x02, 
    c = 0x04 
}; 

Answer 2

为你得到（枚举其基本上是一个字内的标志）是使用两个枚举，一个用于位的具体实例中的一种常见方法指数以及实际的位值第二枚举：

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 
}; 

这不是理想的，我知道，但它避免了明确的字面常量。一些糟糕的东西可以用宏来隐藏，你可能认为它不是一件好事。

Answer 3

你可以使用模板元编程自动完成这一转变过程：

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 4

什么你在做工作完全正常：

#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'; 
} 

注：这只是标准C++ 14引入了二进制文字。

否则，你可以使用移位运算符来指定位的位置：

enum x { 
     a = 1 << 0 
    , b = 1 << 1 
    , c = 1 << 2 
}; 

如果你正在寻找节省一些维护工作在以前来定义每个enum另一种可能性定义enums：

enum x { 
     a = 1 
    , b = a << 1 
    , c = b << 1 
    , d = c << 1 
    , e = d << 1 
}; 

这意味着您可以相对无痛地在中间添加元素：

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 5

的一种方式，假设C++ 11，将

constexpr int func(int x) 
{ 
    return x << 1; 
} 

enum X 
{ 
    a = 1, 
    b = func(a), 
    c = func(b) 
}; 

的func()可以被用来实现任何关系，你喜欢连续命名值之间。

C++ 11之前，备选方案可能包括

enum X 
{ 
    a = 1, 
    b = a << 1, 
    c = b << 1 
}; 

或（与宏）

#define func(x) x << 1 
enum X 
{ 
    a = 1, 
    b = func(a), 
    c = func(b) 
}; 
#undef func 

Answer 6

偷伟大idea of Rob，有指定如何递增的价值的方式枚举，这是不是很自动，但只要你的枚举总是相同的领域，你可以做这样的事情：

template <typename T, T(*INC)(const T), T start = {}> 
struct managed_enum 
{ 
    enum 
    { 
     a = start, 
     b = INC(a), 
     c = INC(b), 
    }; 
}; 

有了这个模板，你可以做到以下几点：

template<typename T> 
constexpr T shift_left(const T value) { return value << 1; } 

using shifted = managed_enum<int, shift_left<int>, 1>; 

你正在寻找（see here）枚举导致。那么，shifted不是一个枚举，而是一个结构，希望它没有关系。

定义不同的增值功能，您可以枚举不同的家庭自动增加，只要所有的人都只有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>>;