C ++双枚举值分配

Question

In an open source code I found an enum initialization that looked like that:

enum example {
    FIRST,
    FIRST_AGAIN = FIRST,
    SECOND,
    ETC
};

I was surprised how the values of the enum are going to be initialized, because the FIRST_AGAIN would get the value 0 because FIRST is 0 , too. But i thought it could affect the FIRST value to be -1 , when the FIRST_AGAIN value is 0 .

So I looked with the debugger what values are assigned to the key words. FIRST and FIRST_AGAIN are assigned with 0 .

So, my question is, is it really allowed (GCC compiles it, but what does the C++ standard say?) to assign two key words in an enumaration with the same value? And how does the compiler translate the assignment? Because to know the value of FIRST , the compiler should gone through the whole enum first and look if any key word is assigned, back from there, he could assign all the other values, but he doesn't know what the assignment FIRST_AGAIN = FIRST means.

Maybe the question is stupid and it's common use to do something like that. What would be the benefits of assigning two key words with the same value?

Answer 1

So, my question is, is it really allowed (GCC compiles it, but what does the C++ standard say?) to assign two key words in an enumaration with the same value?

That's fine. The C++ standard doesn't say anything about it in the normative text, so it's implicitly allowed, but does include an example:

 enum { a, b, c=0 }; 

Which defines a and c as zero.

And how does the compiler translate the assignment? Because to know the value of FIRST , the compiler should gone through the whole enum first

No, the compiler doesn't need to do that. An enumerator definition without an explicit value doesn't depend on later enumerator definitions. Its value is the value of the previous enumerator plus one, or zero if there were no previous enumerators.

Maybe the question is stupid and it's common use to do something like that. What would be the benefits of assigning two key words with the same value?

One possibility:

enum E {
  A = 20,
  B = 30,
  C = 40,
  MIN = A,
  MAX = C
}

Here, it may be expected that the values of MIN and MAX may change as enumerators are added or removed, but the values of A , B and C are expected to remain constant. By using C where C is wanted, and MIN and MAX where a range is wanted, code may be future-proof for later versions of whatever library defines this enumeration.