What Is a Union?
A union is a block of memory that is used to hold data items of different types. In C, a union is similar to a structure, except that data items saved in the union are overlaid in order to share the same memory location. More details on the differences between unions and structures are discussed in the following sections.
Declaring Unions
The syntax for declaring a union is similar to the syntax for a structure. The following is an example of a union declaration:
union automobile {
int year;
char model[8];
int engine_power;
float weight;
};
Here union is the keyword that specifies the union data type. automobile is the tag name of the union. The variables, such as year, model, engine_power, and weight, are members of the union, and are declared within the braces ({ and }). The union declaration ends with a semicolon (;).
Like a structure tag name, a union tag name is a label to a union, which is used by the compiler to identify the union.
Defining Union Variables
You can define union variables after declaring a union. For instance, the following union variables are defined with the union labeled with automobile from the previous section:
union automobile sedan, pick_up, sport_utility;
Here the three variables, sedan, pick_up, and sport_utility, are defined as the union variables.
Of course, you can declare a union and define variables of the union in a single statement. For instance, you can rewrite the previous union declaration and definition like this:
union automobile {
int year;
char model[8];
int engine_power;
float weight;
} sedan, pick_up, sport_utility;
Here three union variables, sedan, pick_up, and sport_utility, are defined by the union of automobile in which there are four members of different data types. If you declare a union and define variables of the union in a single statement, and there is no more union variable definition made with the union, you can omit the tag name of the union. For instance, the tag name automobile can be omitted in the union definition like this:
union {
int year;
char model[8];
int engine_power;
float weight;
} sedan, pick_up, sport_utility;
Referring a Union with . or ->
As well as being used to reference structure members, the dot operator (.) can be used in referencing union members. For example, the following statement assigns the value of 1997 to one of the members of the sedan union:
sedan.year = 1997;
Here the dot operator is used to separate the union name sedan and the member name year. In addition, if you define a pointer ptr like this:
union automobile *ptr;
then you can reference one of the union members in the following way:
ptr->year = 1997;
Here the arrow operator (->)is used to reference the union member year with the pointer ptr.
The program in Listing 20.1 gives another example of how to reference and assign values to the members of a union.
TYPE
Listing 20.1. Referencing the members of a union.
1: /* 20L01.c Referencing a union */
2: #include <stdio.h>
3: #include <string.h>
4:
5: main(void)
6: {
7: union menu {
8: char name[23];
9: double price;
10: } dish;
11:
12: printf("The content assigned to the union separately:\n");
13: /* reference name */
14: strcpy(dish.name, "Sweet and Sour Chicken");
15: printf("Dish Name: %s\n", dish.name);
16: /* reference price */
17: dish.price = 9.95;
18: printf("Dish Price: %5.2f\n", dish.price);
19:
20: return 0;
21: }
After running the executable 20L01.exe of the program in Listing 20.1, I have the following output shown on my screen:
OUTPUT
C:\app>20L01
The content assigned to the union separately:
Dish Name: Sweet and Sour Chicken
Dish Price: 9.95
C:\app>
ANALYSIS
The purpose of the program in Listing 20.1 is to show you how to reference union members with the dot operator.
Inside the main() function, a union, called dish, is first defined with the union data type of menu in lines 7_10. There are two members, name and price, in the union.
Then the statement in line 14 assigns the string "Sweet and Sour Chicken" to the character array name that is one of the union members. Note that the dish.name expression is used as the first argument to the strcpy() function in line 14. When the compiler sees the expression, it knows that we want to reference the memory location of name that is a member of the dish union.
The strcpy() function is a C function that copies the contents of a string pointed to by the function's second argument to the memory storage pointed to by the function's first argu-ment. I included the header file string.h in the program before calling the strcpy() function. (See line 3.)
Line 15 prints out the contents copied to the name array by using the dish.name expression one more time.
The statement in line 17 assigns the value 9.95 to the double variable price, which is another member for the dish union. Note that the dish.price expression is used to reference the union member. Then line 18 displays the value assigned to price by calling the printf() function and passing the dish.price expression as an argument to the function.
According to the results shown in the output, the two members of the dish union, name and price, have been successfully referenced and assigned corresponding values.
