Do you know that? 85% either strongly agree or moderately agree that they are happier now than they were before becoming a freelancer. next

What is the benefit of using an enum rather than a #define constant?

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. The first advantage is that enumerated constants are generated automati-
cally 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 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

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. Because you don't have to worry about the actual values, defining your constants using the
enumerated method is easier than using the symbolic constant method. The enumerated method also helps
prevent accidentally reusing the same number for different constants.

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. For instance, consider
the following piece of code:

void copy_file(char* source_file_name, char* dest_file_name)
{
     ...
     Error_Code err;
     ...
      if (drive_ready() != TRUE)
          err = DRIVE_NOT_READY;
     ...
}

Looking at this example, you can derive from the definition of the variable err that err should be assigned
only numbers of the enumerated type Error_Code. Hence, if another programmer were to modify or add
functionality to this program, the programmer would know from the definition of  Error_Code what
constants are valid for assigning to err.

Conversely, if the same example were to be applied using the symbolic constant method, the code would look
like this:

void copy_file(char* source_file, char* dest_file)
{
     ...
     int err;
     ...
     if (drive_ready() != TRUE)
          err = DRIVE_NOT_READY;
     ...
}

Looking at the preceding example, a programmer modifying or adding functionality to the copy_file()
function would not immediately know what values are valid for assigning to the  err variable. The
programmer would need to search for the #define DRIVE_NOT_READY statement and hope that all relevant
constants are defined in the same header file. This could make maintenance more difficult than it needs to
be and make your programs harder to understand.

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.