The use of an enumeration constant (enum) has many advantages over using the traditional symbolic constant

style of #define. These advantages include a lower maintenance requirement, improved program readability,

and better debugging capability. 

 

1) The first advantage is that enumerated constants are generated automatically by the compiler. Conversely, symbolic constants must be manually assigned values by the programmer.

For instance, if you had an enumerated constant type for error codes that could occur in your program, your

enum definition could look something like this:

enum Error_Code

{

OUT_OF_MEMORY,

INSUFFICIENT_DISK_SPACE,

LOGIC_ERROR,

FILE_NOT_FOUND

};

In the preceding example, OUT_OF_MEMORY is automatically assigned the value of 0 (zero) by the compiler

because it appears first in the definition. The compiler then continues to automatically assign numbers to

the enumerated constants, making INSUFFICIENT_DISK_SPACE equal to 1, LOGIC_ERROR equal to 2, and FILE_NOT_FOUND equal to 3, so on.

If you were to approach the same example by using symbolic constants, your code would look something like this:

#define OUT_OF_MEMORY 0

#define INSUFFICIENT_DISK_SPACE 1

#define LOGIC_ERROR 2

#define FILE_NOT_FOUND 3

values by the programmer. Each of the two methods arrives at the same result: four constants assigned numeric values to represent error codes. Consider the maintenance required, however, if you were to add two constants to represent the error codes DRIVE_NOT_READY and CORRUPT_FILE. Using the enumeration constant method, you simply would put these two constants anywhere in the enum definition. The compiler would generate two unique values for these constants. Using the symbolic constant method, you would have to manually assign two new numbers to these constants. Additionally, you would want to ensure that the numbers you assign to these constants are unique.

2) Another advantage of using the enumeration constant method is that your programs are more readable and

thus can be understood better by others who might have to update your program later.

3) A third advantage to using enumeration constants is that some symbolic debuggers can print the value of an

enumeration constant. Conversely, most symbolic debuggers cannot print the value of a symbolic constant.

This can be an enormous help in debugging your program, because if your program is stopped at a line that

uses an enum, you can simply inspect that constant and instantly know its value. On the other hand, because

most debuggers cannot print #define values, you would most likely have to search for that value by manually

looking it up in a header file.