What can I do with an enum variable?

When I declare a enum variable like this:

enum paint_colors { RED, GREEN, BLUE, ..开发者_运维问答.} colors;

is the colors variable useful? If so, what can I do with it?

Thanks in advance.

---

Internally, an enum is treated as an integer that can only hold a limited range of values. In this case, the constants RED, GREEN, BLUE, ... will be defined and will be equal to 0, 1, 2, ... (respectively). The variable colors can be used anywhere an int can be used. You can use operators like ++ to iterate through the list of colors. The only difference between declaring enum paint_colors colors and int colors is that the enumerated variable can should only be assigned one of the enumerated constants.

This gives you several benefits over using #define to create a series of constants and using a normal int for colors. First, some debuggers can detect that colors is an enumerated type and will display the name of the enumerated constant instead of a numeric value.

More importantly, this can add an additional layer of type checking. It is not required by the C standard, but some compilers check and make sure that values assigned to a variable of enumerated type correspond to one of the enumerated constants.

Mentally, you can almost think of this is similar to saying:

#define RED    0
#define GREEN  1
#define BLUE   2
typedef int paint_colors;
paint_colors colors;

The variable is treated like an int, but explicitly giving it a different type helps to clarify what the variable is and what it is used for.

---

Really what you're doing there is declaring a variable inline with the rest of the definition of the enumeration. It's equivalent to:

enum paint_colors { RED, GREEN, BLUE };
enum paint_colors colors;

Often, you'll see a typedef associated with the definition:

typedef enum _paint_colors { RED, GREEN, BLUE } paint_colors;

Which lets you use the enumeration more like the built in types:

paint_colors color;

So the answer to your question is that colors is a variable of type enum paint_colors, and can be used any way you think is appropriate for such a variable:

colors = RED;
if (colors != GREEN)
{
    colors = BLUE;
}

And so on.

---

In C, the enum type variable can be iterated, such as ++, +; But this is not allowed in C++;

enum WEEKDAY {MON, TUE, WED, THU, FRI, SAT, SUN, END};
for(WEEKDAY day = 0; day < END; day++){
    printf("day index = %d\n", day);
}

can be compiled in C, but not in C++;

---

You could paint a roller coaster!

typedef struct {
  Color car;
  Color door_handle;
  Color wheels;
} RollerCoasterColors;

int main(void) {
  RollerCoasterColors roller_coaster_colors;
  roller_coaster_colors.car = RED;
  roller_coaster_colors.door_handle = YELLOW;
  roller_coaster_colors.wheels = PURPLE;

  // now paint_roller_coaster() knows what colour to paint each part!
  paint_roller_coaster(roller_coaster_colors);
}

---

An enum is helpful when you have a given set of possible values, where each value has a meaningful name. Elsewhere, you refer to the enum values, rather than "magic numbers", which can become meaningless among other code.

---

enum paint_colors { RED, GREEN, BLUE, ...} colors;

This is the enumeration type declaration you have made. Answering specifically to your question, you can declare an int variable as usual,

enum paint_colors { RED, GREEN, BLUE, ...};
int colors;

and perform all operations on colors variable same as you would have done with your declaration. It will not make any difference in operation part. Be it assigning a integer value outside the enumerators constant value,

colors=1676;    //Valid in both of our case

The only difference it makes is making the code more readable and better to understand because enum type variable indicates its purpose to the programmer(specially debugger). Depends on you ;)

---

I find enums especially useful during debugging. If you just use #define to define constants used as values for some variable the debugger will show you the numer. With enum it can show you the names.

And if you need a set of possible values (constants) for a single variable you can define it the way you showed.