The enum Data Type
The C language provides you with an additional data type—the enum data type. enum is short for enumerated. The enumerated data type can be used to declare named integer constants. The enum data type makes the C program more readable and easier to maintain. (Another way to declare a named constant is to use the #define directive, which is introduced later in this book.)
Declaring the enum Data Type
The general form of the enum data type declaration is
enum tag_name {enumeration_list} variable_list;
Here tag_name is the name of the enumeration. variable_list gives a list of variable names that are of the enum data type. enumeration_list contains defined enumerated names that are used to represent integer constants. (Both tag_name and variable_list are optional.)
For instance, the following declares an enum data type with the tag name of automobile:
enum automobile {sedan, pick_up, sport_utility};
Given this, you can define enum variables like this:
enum automobile domestic, foreign;
Here the two enum variables, domestic and foreign, are defined.
Of course, you can always declare and define a list of enum variables in a single statement, as shown in the general form of the enum declaration. Therefore, you can rewrite the enum declaration of domestic and foreign like this:
enum automobile {sedan, pick_up, sport_utility} domestic, foreign;
Assigning Values to enum Names
By default, the integer value associated with the leftmost name in the enumeration list field, surrounded by the braces ({ and }), starts with 0, and the value of each name in the rest of the list increases by one from left to right. Therefore, in the previous example, sedan, pick_up, and sport_utility have the values of 0, 1, and 2, respectively.
In fact, you can assign integer values to enum names. Considering the previous example, you can initialize the enumerated names like this:
enum automobile {sedan = 60, pick_up = 30, sport_utility = 10};
Now, sedan represents the value of 60, pick_up has the value of 30, and sport_utility assumes the value of 10.
The program shown in Listing 18.1 prints out the values of enum names.
TYPE
Listing 18.1. Defining enum data types.1: /* 18L01.c: Defining enum data types */
2: #include <stdio.h>
3: /* main() function */
4: main()
5: {
6: enum language {human=100,
7: animal=50,
8: computer};
9: enum days{SUN,
10: MON,
11: TUE,
12: WED,
13: THU,
14: FRI,
15: SAT};
16:
17: printf("human: %d, animal: %d, computer: %d\n",
18: human, animal, computer);
19: printf("SUN: %d\n", SUN);
20: printf("MON: %d\n", MON);
21: printf("TUE: %d\n", TUE);
22: printf("WED: %d\n", WED);
23: printf("THU: %d\n", THU);
24: printf("FRI: %d\n", FRI);
25: printf("SAT: %d\n", SAT);
26:
27: return 0;
28: }
The following output is shown on the screen after the executable, 18L01.exe, of the program in Listing 18.1 is created and executed:
OUTPUT
C:\app>18L01
human: 100, animal: 50, computer: 51
SUN: 0
MON: 1
TUE: 2
WED: 3
THU: 4
FRI: 5
SAT: 6
C:\app>
ANALYSIS
The purpose of the program in Listing 18.1 is to show you the default values of the enum names, as well as the values assigned to some enum names by the programmer.
As you can tell, there are two enum declarations, in lines 6_8 and lines 9_15, respectively. Note that the variable lists in the two enum declarations are omitted because there is no need for the variable lists in the program.
The first declaration has a tag name called language and three enumerated names, human, animal, and computer. In addition, human is assigned the value of 100; animal is initialized with 50. According to the enum definition, the default value of computer is the value of animal increased by 1. Therefore, in this case, the default value of computer is 51.
The output made by the statement in line 17 shows that the values of human, animal, and computer are indeed 100, 50, and 51.
The second enum declaration in the program contains seven items with their default values. Then, lines 19_25 print out these default values one at a time. It is not surprising to see that the values represented by the enumerated names, SUN, MON, TUE, WED, THU, FRI, and SAT, are 0, 1, 2, 3, 4, 5, and 6, respectively.
Now, let's look at another example, shown in Listing 18.2, that demonstrates how to use the enum data type.
TYPE
Listing 18.2. Using the enum data type.1: /* 18L02.c: Using the enum data type */
2: #include <stdio.h>
3: /* main() function */
4: main()
5: {
6: enum units{penny = 1,
7: nickel = 5,
8: dime = 10,
9: quarter = 25,
10: dollar = 100};
11: int money_units[5] = {
12: dollar,
13: quarter,
14: dime,
15: nickel,
16: penny};
17: char *unit_name[5] = {
18: "dollar(s)",
19: "quarter(s)",
20: "dime(s)",
21: "nickel(s)",
22: "penny(s)"};
23: int cent, tmp, i;
24:
25: printf("Enter a monetary value in cents:\n");
26: scanf("%d", ¢); /* get input from the user */
27: printf("Which is equivalent to:\n");
28: tmp = 0;
29: for (i=0; i<5; i++){
30: tmp = cent / money_units[i];
31: cent -= tmp * money_units[i];
32: if (tmp)
33: printf("%d %s ", tmp, unit_name[i]);
34: }
35: printf("\n");
36: return 0;
37: }
While the executable (18L02.exe) is being executed, I enter 141 (for 141 cents) and obtain the following output from the screen:
OUTPUT
C:\app>18L02
Enter a monetary value in cents:
141
Which is equivalent to:
1 dollar(s) 1 quarter(s) 1 dime(s) 1 nickel(s) 1 penny(s)
C:\app>
ANALYSIS
The purpose of the program in Listing 18.2 is to use the enum data type to represent the value of the amount of money entered by the user.
Inside the main() function, an enum declaration with a tag name of units is made in lines 6_10. The numbers assigned to the enumerated names are based on their ratios to the unit of cent. For instance, one dollar is equal to 100 cents. Therefore, the enum name dollar is assigned the value of 100.
After the enum declaration, an int array, called money_units, is declared, and is initialized with the enumerated names from the enum declaration. According to the definition of the enum data type, the declaration of the money_units array in the program is actually equivalent to the following one:
int money_units[5] = {
100,
25,
10,
5,
1};
So now you see that you can use enumerated names, instead of integer numbers, to make up other expressions or declarations in your program.
In lines 17_22, an array of pointers, unit_name, is declared and initialized. (The usage of arrays of pointers was introduced in Hour 16, "Applying Pointers.")
Then, the statement in line 15 asks the user to enter an integer number in the unit of cent. The scanf() function in line 26 stores the number entered by the user to an int variable called cent.
The for loop in lines 29_34 divides the entered number and represents it in a dollar-quarter-dime-nickel-penny format.
Note that the integer constants represented by the enumerated names are used in lines 30 and 31, through the money_units array. If the value of a unit is not 0, a corresponding string pointed to by the array of pointers, unit_name, is printed out in line 33. Therefore, when I enter 141 (in unit of cent), I see its equivalent in the output: 1 dollar(s) 1 quarter(s) 1 dime(s) 1 nickel(s) 1 penny(s).
- 10 views
