枚举映射对重构具有鲁棒性

Question

我想将（范围内的）枚举的值映射到其他一些值。例如，这里我将 Color 映射到其他枚举 Group:

enum class Color {
  Red, Green, Blue, Cyan, Magenta, Yellow, White, Black, 
  COUNT  // Needed to know the number of items
};
enum class Group {
  Primary, Secondary, Neutral
};

Group GetGroupOfColor(Color color);  // Mapping function I'm going to implement

我想确保 如果有人更改 Color 枚举中的元素数量，此函数将无法编译。

我想到了解决这个问题的唯一办法：

Group GetGroupOfColor(Color color)
{
  static const Group color2group[] = {
    Group::Primary,    // Red
    Group::Primary,    // Green
    Group::Primary,    // Blue
    Group::Secondary,  // Cyan
    Group::Secondary,  // Magenta
    Group::Secondary,  // Yellow
    Group::Neutral,    // White
    Group::Neutral     // Black
  };
  static_assert(ARRAY_SIZE(color2group) == size_t(Color::COUNT), "DEADBEEF!");

  auto index = size_t(color);
  assert(index < size_t(Color::COUNT));
  return color2group[index];
}

其中 ARRAY_SIZE 可以像下面这样实现：

template <typename T, size_t N>
constexpr size_t ARRAY_SIZE(T(&)[N])
{
  return N;
}

这个实现符合我的要求，但它有很多缺点：

在 Color 枚举中添加这个丑陋的 COUNT 项（最让我烦恼）
如果有人重新订购 Color
不适用于不连续的枚举，即具有明确分配的值（这不是很重要）

我的问题是，是否有改进此实现的方法？也许是一些我什至没有想到的不同方法。也许有它自己的缺点，我会觉得不那么烦人。

另请参阅：

Number of elements in an enum
Compile time sizeof_array without using a macro

Answer 1

我会使用 switch 语句。

switch (colour) {
    case Colour::Red:   return Group::Primary;
    //...
    case Colour::Black: return Group::Neutral;
}
return Group::Invalid;  // or throw, assert, or whatever.

这应该能满足您的所有需求：

Adds this ugly COUNT item in Color enum (bothers me most)

不需要那个，每个枚举器只需要 case。

Will fail silently if someone reorders items of Color

每个 case 都明确命名，因此每个枚举器的值都无关紧要（只要它们是唯一的；但如果不是这样，您将收到错误消息）。

Not applicable for not-continuous enums

同样，命名 case 语句不关心实际值。

if anyone changes the number of elements in Color enum, this function will fail to compile

虽然不能保证，但如果开关中有未处理的枚举器（只要没有 default 分支），大多数编译器应该能够发出警告。对于 GCC，选项是 -Wswitch（包含在 -Wall 中），如果您希望它导致失败，则选项是 -Werror。

Answer 2

稍微不同的方法如何 - 创建一种丰富的枚举：

class Color {
  public :
    enum class Name { RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, WHITE, BLACK };
    enum class Group { PRIMARY, SECONDARY, NEUTRAL };

    uint32_t rgb;
    Name name;
    Group group;

    static const Color Red;
    static const Color Green;
    static const Color Blue;
    static const Color Cyan;
    static const Color Magenta;
    static const Color Yellow;
    static const Color White;
    static const Color Black;

  private :
    Color(uint32_t rgb, Name name, Group group) : rgb(rgb), name(name), group(group) { }

  public :
    inline operator const Name() const { return name; }
};

const Color Color::Red     = Color(0xFF0000, Color::Name::RED,     Color::Group::PRIMARY);
const Color Color::Green   = Color(0x00FF00, Color::Name::GREEN,   Color::Group::PRIMARY);
const Color Color::Blue    = Color(0x0000FF, Color::Name::BLUE,    Color::Group::PRIMARY);
const Color Color::Cyan    = Color(0x00FFFF, Color::Name::CYAN,    Color::Group::SECONDARY);
const Color Color::Magenta = Color(0xFF00FF, Color::Name::MAGENTA, Color::Group::SECONDARY);
const Color Color::Yellow  = Color(0xFFFF00, Color::Name::YELLOW,  Color::Group::SECONDARY);
const Color Color::White   = Color(0xFFFFFF, Color::Name::WHITE,   Color::Group::NEUTRAL);
const Color Color::Black   = Color(0x000000, Color::Name::BLACK,   Color::Group::NEUTRAL);

然后可以像这样使用：

void fun(const Color& color) {
    switch (color) {
        case Color::Name::RED   : std::cout << "red"; break;
        case Color::Name::GREEN : std::cout << "green"; break;
        case Color::Name::BLUE  : std::cout << "blue"; break;
        // etc.
    }
    std::cout << " ";
    switch (color.group) {
        case Color::Group::PRIMARY   : std::cout << "primary"; break;
        case Color::Group::SECONDARY : std::cout << "secondary"; break;
        case Color::Group::NEUTRAL   : std::cout << "neutral"; break;
    }
    std::cout << " : " << std::hex << color.rgb << std::endl;
}

Answer 3

我怀疑您希望检测 Color 枚举的更改，因为您希望确保每种颜色始终可以映射到某个组？如果是这样，您可以使用一些宏来建立映射，这样就不可能在不定义映射到的内容的情况下添加新的 Color 值。类似于：

#define COLORMAP \
  MAP_COLOR(Red, Primary) \
  MAP_COLOR(Green, Primary) \
  MAP_COLOR(Blue, Primary) \
  MAP_COLOR(Cyan, Secondary) \
  MAP_COLOR(Magenta, Secondary) \
  MAP_COLOR(Yellow, Secondary) \
  MAP_COLOR(White, Neutral) \
  MAP_COLOR(Black, Neutral)

适当地定义 MAP_COLOR 将允许您定义 Color 枚举以及来自单一来源的映射函数：

#define MAP_COLOR(a, b) a,
enum class Color {
  COLORMAP
  Invalid
};
#undef MAP_COLOR

enum class Group {
  Primary, Secondary, Neutral, Invalid
};

#define MAP_COLOR(a, b) case Color::a: return Group::b;
Group GetGroupOfColor(Color color)
{
  switch (color) {
    COLORMAP
    case Color::Invalid: return Group::Invalid;
  }
  return Group::Invalid;
}

枚举映射对重构具有鲁棒性

Enum mapping robust to refactoring

c++

enums

c++14