C++ FAQ Celebrating Twenty-One Years of the C++ FAQ!!!
(Click here for a personal note from Marshall Cline.)
Section 29:
[29.20] If an enumeration type is distinct from any other type, what good is it? What can you do with it?

Let's consider this enumeration type: enum Color { red, white, blue };.

The best way to look at this (C programmers: hang on to your seats!!) is that the values of this type are red, white, and blue, as opposed to merely thinking of those names as constant int values. The C++ compiler provides an automatic conversion from Color to int, and the converted values will be, in this case, 0, 1, and 2 respectively. But you shouldn't think of blue as a fancy name for 2. blue is of type Color and there is an automatic conversion from blue to 2, but the inverse conversion, from int to Color, is not provided automatically by the C++ compiler.

Here is an example that illustrates the conversion from Color to int:

enum Color { red, white, blue };

void f()
{
  int n;
  n = red;    // change n to 0
  n = white;  // change n to 1
  n = blue;   // change n to 2
}
The following example also demonstrates the conversion from Color to int:
void f()
{
  Color x = red;
  Color y = white;
  Color z = blue;

  int n;
  n = x;   // change n to 0
  n = y;   // change n to 1
  n = z;   // change n to 2
}
However the inverse conversion, from int to Color, is not automatically provided by the C++ compiler:
void f()
{
  Color x;
  x = blue;  // change x to blue
  x = 2;     // compile-time error: can't convert int to Color
}
The last line above shows that enumeration types are not ints in disguise. You can think of them as int types if you want to, but if you do, you must remember that the C++ compiler will not implicitly convert an int to a Color. If you really want that, you can use a cast:
void f()
{
  Color x;
  x = red;      // change x to red
  x = Color(1); // change x to white
  x = Color(2); // change x to blue
  x = 2;        // compile-time error: can't convert int to Color
}
There are other ways that enumeration types are unlike int. For example, enumeration types don't have a ++ operator:
void f()
{
  int n = red;    // change n to 0
  Color x = red;  // change x to red

  n++;   // change n to 1
  x++;   // compile-time error: can't ++ an enumeration (though see caveat below)
}
Caveat on the last line: it is legal to provide an overloaded operator that would make that line legal, such as definining operator++(Color& x).