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

Question

有没有办法改变枚举设置常量值的方式？通常它是递增一，但我想应用另一条规则。在PAWN中，这将起的作用

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

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

Answer 1

不是自动的，但您可以手动指定每个值

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

Answer 2

您可以使用模板元编程来自动化这个转换过程：

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

假设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 4

对于您给出的特定示例（枚举本质上是单词中的标志），一种常见的方法是使用两个枚举，一个用于位索引，另一个用于实际位值：

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 5

你所做的一切都很好：

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

如果您希望节省一些维护工作，另一种可能性是根据先前定义的enums:定义每个enum

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 6

窃取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>;

您正在查找的枚举上的结果（请参见此处）。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>>;