Enum Size *in practice*

Question

For C++ prior 2011, the standard says that enums can be any size, from byte to long long. But in practice it seems most compilers make them ints, 4 bytes.

So, in practice do any vaguely current compilers not make them ints?

And I seem to need to clarify that I am not doing anything weird, like enums > 2^31. Just simple enums. And on 32 or 64 bit systems, my software will not run on 16 bits!

Answer 1

Let's see it on any modern compiler:

#include <iostream>
#include <limits>

enum MySmallSmall {
  SmallValue = 0,
};

enum MyLongLong {
  LongValue = std::numeric_limits<long long>::max()
};

int main() {
  std::cout << "sizeof MySmallSmall is " << sizeof(MySmallSmall) << std::endl;
  std::cout << "sizeof MyLongLong is " << sizeof(MyLongLong) << std::endl;
  return 0;
}

clang and g++ output:

sizeof MySmallSmall is 4

sizeof MyLongLong is 8

But for MS Visual Studio both results are 4 (I've checked it using this site http://rextester.com/l/cpp_online_compiler_visual not sure what compiler version is here)

So you can't rely on sizeof of any enum.

Answer 2

If an enum was always an int, then the following would be unsafe:

enum oops {
    foo = 32767,
    bar, /*what am I?*/
};

This is because an int can be as small as 16 bits (and that is still surprisingly common). On a system with a 32 bit int, you could set foo = 2147483647 and your compiler most certainly wouldn't pick an int as the underlying type.

So the clever C++ bods specify that the underlying enum integral type must be capable of representing the values given, and a compiler is free to pick one that's appropriate. Given that int is often considered as the machine's native type, it's often a sensible choice.

If you want to know the underlying type of an enum, then std::underlying_type provides this.