Do C++ enums Start at 0?

by

Per that standard [dcl.enum]

The enumeration type declared with an enum-key of only enum is an unscoped enumeration, and its enumerators are unscoped enumerators. The enum-keys enum class and enum struct are semantically equivalent; an enumeration type declared with one of these is a scoped enumeration, and its enumerators are scoped
enumerators. The optional identifier shall not be omitted in the declaration of a scoped enumeration. The type-specifier-seq of an enum-base shall name an integral type; any cv-qualification is ignored. An opaqueenum-declaration declaring an unscoped enumeration shall not omit the enum-base. The identifiers in an enumerator-list are declared as constants, and can appear wherever constants are required. An enumeratordefinition with = gives the associated enumerator the value indicated by the constant-expression. If the first
enumerator has no initializer, the value of the corresponding constant is zero. An enumerator-definition without an initializer gives the enumerator the value obtained by increasing the value of the previous enumerator by one.

Emphasis mine

So yes, if you do not specify a start value, it will default to 0.

I would really like to see an answer that confirms this for C++, but I’d also like to know if an ordinal 0 holds even if I specify a value in the middle of an enum:

This also works. It will start at 0 and increment up along the way. Then after the enum you assign the value to it will begin to increase by one from that value for subsequent enumerator.

More Related Contents:

  1. Enumerate over an enum in C++
  2. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  3. Will std::string always be null-terminated in C++11?
  4. Is the compiler allowed to optimize out heap memory allocations?
  5. Base enum class inheritance
  6. Is passing a C++ object into its own constructor legal?
  7. Allow for Range-Based For with enum classes?
  8. std::ignore with structured bindings?
  9. So why is i = ++i + 1 well-defined in C++11?
  10. Why is it not possible to overload class templates?
  11. treating memory returned by operator new(sizeof(T) * N) as an array
  12. Is circumventing a class’ constructor legal or does it result in undefined behaviour?
  13. Static member access in constant expressions
  14. Why is f(i = -1, i = -1) undefined behavior?
  15. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  16. Why does `int ;` compile fine in C, but not in C++?
  17. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  18. How to use C++11 enum class for flags
  19. Can I Reference Previous Members of an Initializer List?
  20. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  21. Are int8_t and uint8_t intended to be char types?
  22. Why doesn’t an if constexpr make this core constant expression error disappear?
  23. what is the size of an enum type data in C++?
  24. Use of typename keyword with typedef and new
  25. Lifetime of object is over before destructor is called?
  26. Are pointers to non-static member function “formally” not considered pointers
  27. Is it allowed for a compiler to optimize away a local volatile variable?
  28. reinterpret_cast between char* and std::uint8_t* – safe?
  29. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  30. Will I be able to declare a constexpr lambda inside a template parameter?

Leave a Comment