您可以为enum定义一个operator++()。这样做的优点是使用了众所周知的标准递增运算符范例。:)
根据你的枚举是否是连续的，你可以将它们视为int或使用开关：

Some& operator++(Some& obj)
{
# if YOUR_ENUMS_ARE_CONTIGUOUS
  int i = obj;
  if( ++i > Some_Total ) i = Some_Alpha;
  return obj = static_cast<Some>(i);
# else 
  switch(obj)
  {
    case Some_Alpha : obj = Some_Beta;  break;
    case Some_Beta  : obj = Some_Gamma; break;
    case Some_Gamma : obj = Some_Total; break;
    case Some_Total : obj = Some_Alpha; break;
    default: assert(false); // changed enum but forgot to change operator
  }
  return obj;
# endif
}

请注意，如果定义了operator++()，用户可能也会期望operator--()。

不，没有办法做到这一点，因为不能保证有人没有写过类似的代码：

enum Some 
{
   Some_Alpha = 0,
   Some_Beta,
   Some_Gamma = 42,
   Some_Delta, 
  Some_Total
};

可以使用静态类成员。
示例中的article及其source code。

在C++11（可能更早）中，你可以使用下面的技巧，使Some可迭代：

Some operator++(Some& s) {
    return s = (Some )(std::underlying_type<Some>::type(x) + 1); 
}
Some operator*(Some s) {
    return s;
} 
Some begin(Some s) {
    return Some_Alpha;

Some end(Some s) {
    return Some_Gamma;
}

int main() { 
    // the parenthesis here instantiate the enum
    for(const auto& s : Some()) { 
        // etc. etc.
    }
    return 0;
}

(This答案是无耻地改编自here。）

enum Some
{
   Some_first_ = 0,
   Some_Alpha = Some_first_,
....
   Some_last_
};

这样做你可以授予第一和最后永远不会改变秩序

如果不使用任何赋值，则枚举将保证是顺序的，从0开始作为第一个。其他人
你能做的最好的事情就是在枚举定义中按照你想要的顺序保存它们，然后用for循环遍历它们。

我将所有Enum放在它们自己的命名空间中。示例：

namespace Foo {
enum Enum {
    First=0, // must be sequential
    Second,
    Third,
    End // must be last
};
}

在代码中：

for (int i=Foo::First; i!=Foo::End; i++) {
// do stuff
}

这是因为C++允许这样的东西（没有在编译器中测试）：

enum Foo {
Alpha = 1
};

enum Bar {
Beta = 2
};

Foo foo = Beta;

这显然是错误的。