控制枚举值的可见性

Question

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

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

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

明显的黑客是：

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

我首先想到的是尝试和你悠悠地解决问题，但有点反思之后，我将负担转移到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); } 

它使用一个邪恶的宏观和模糊的预处理机器，以避免代码duplicaton。它显然只适用于连续的枚举元素（它返回元素的数量，而不是最大数量）。

Answer 2

一个解决办法是使用地图：

std::map<color, unsigned> LEDs_in_stock; 

LEDs_in_stock[red] += 2; 

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

这样，你让你枚举干净，不需要硬编码任何尺寸。

Answer 3

是将枚举放入基类中的一个选项吗？

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 4

在保护您的未来维护者免于犯简单/容易错误，并试图阻止某些应该是明显是错误（如使用NUM_COLORS值）之间存在一条细线。

在你的情况下，我会建议在关键函数声明输入并将其留在那里。

我相信你可以使用专门的模板代理类和static_assert S于NUM_COLORS，以防止用户将其传递到你的函数。

我输入了一些似乎可行的东西。

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