控制枚举值的可见性

Question

考虑一个导出枚举的 C++ 类，在该枚举上维护一个内部数组，并希望导出一个接受枚举值的命令。

class foo {
public:
  enum color {
    red,
    yellow,
    green,
    NUM_COLORS
  };
private:
  something somebody[NUM_COLORS];
public:
  void command(color c);
};

有没有一种干净的方法可以只导出实际颜色，而不是 NUM_COLORS？当编译器的类型系统真的应该能够为我做这件事时，我不想在每次调用时都检查边缘情况。

明显的 hack 是：

class foo {
public:
  enum color {
    red,
    yellow,
    green
  };
private:
  /* something like */ const unsigned NUM_COLORS = green+1;
  unsigned LEDs_in_stock[NUM_COLORS];
public:
  void command(color c);
};

这当然是一个定时炸弹，等待一些可怜的过度劳累的维护程序员为蓝色 LED 添加规定，然后忘记更新 NUM_COLORS 行。

让我澄清一下。在这种特殊情况下，我想要的是能够说：

class foo {
public:
  enum color {
    red,
    yellow,
    green
  };
  void command(color c);
private:
  something somebody[color];
};

据我了解，C++ 不允许这样做。

Answer 1

将枚举放入基类是一种选择吗？

class foo_enums {
public:
  enum color {
    red,
    yellow,
    green,
    NUM_COLORS
  };

protected:
  foo_enums() { }
  ~foo_enums() { }
};

class foo : public foo_enums {
private:
  unsigned LEDs_in_stock[NUM_COLORS];

  /* make NUM_* values inaccessible */
  using foo_enums::NUM_COLORS;

public:
  void command(color c);
};

我个人不会这样做，因为它看起来像一个过于复杂的工作。我会简单地禁止调用者传递NUM_COLORS。没错，类型系统不会检查这一点。但对于人类程序员来说，这无疑是一件容易的事情。为什么他们会通过NUM_COLORS？

Answer 2

我的第一个想法是尝试解决问题，但经过一番反思，我会将负担转移到command：

void command(color c) {
  assert(0 <= c && c < NUM_COLORS && "Invalid argument");
}

由于枚举是非常弱的类型，无论如何您都需要检查输入，因为任何人都可以轻松提供蹩脚的参数：

Foo foo;
foo.command(static_cast<Foo::color>(3)); // 3 is green, right ?

---

原解决方案：

class Foo {
  struct impl { enum { red, yellow, green, NUM_COLORS }; };
public:
  enum color { red = impl::red, yellow = impl::yellow, green = impl::green };

  void command(color c);
};

不幸的是，有很多重复发生（实际上我最初输入了green = impl::yellow;，尽管你从不直接引用impl 的值也没关系）。

否则，总有宏招：

#define MY_DEFINE_ENUM(Type, Elements)       \
  enum Type { BOOST_PP_SEQ_ENUM(Elements) }; \
  inline size_t size(Type) { return BOOST_PP_SEQ_SIZE(Elements); }

它使用邪恶的宏和晦涩的预处理器机制来避免代码重复。它显然只适用于连续的枚举元素（它返回元素的数量，而不是最大数量）。

Answer 3

在保护您未来的维护者不犯简单/容易的错误和试图阻止应该明显错误的事情之间有一条很好的界限，例如使用 NUM_COLORS 值。

在您的情况下，我建议在关键功能处声明输入并将其保留。

我相信您可以使用专门的模板代理类和 NUM_COLORS 上的static_asserts 来防止用户将其传递给您的函数。

我输入了一些似乎有用的东西。

class foo {
public:
  enum color {
    red,
    yellow,
    green,
    NUM_COLORS
  };

  class Color_Rep
  {
    color c;
  protected:
    Color_Rep(color which_color) : c(which_color) { }
  };

  template <color C>
  struct Color : public Color_Rep
  {
    Color() : Color_Rep(C) { }
    enum { value = C };
  };

private:
  int bar[NUM_COLORS];

public:
  void command(Color_Rep c);
};

// Deny access to command(NUM_COLORS).
template <>
struct foo::Color<foo::NUM_COLORS>
{
};

int main()
{
    foo().command(foo::Color<foo::red>());
    foo().command(foo::Color<foo::green>());
    foo().command(foo::Color<foo::NUM_COLORS>());  // Won't compile.
}

Answer 4

解决方案是使用地图：

std::map<color, unsigned> LEDs_in_stock;

LEDs_in_stock[red] += 2;

LEDs_in_stock[red]; // = 2
LEDs_in_stock[green]; // = 0

这样可以让你的枚举保持干净，并且不需要硬编码任何大小。