Programming in C (Fourth Edition) (2015)

---

The main() routine asks the user to enter in the time. The scanf() call uses the format string

"%i:%i:%i"

to read the data. Specifying a nonformat character, such as ':', in a format string signals to the scanf() function that the particular character is expected as input. Therefore, the format string listed in Program 8.5 specifies that three integer values are to be input—the first separated from the second by a colon, and the second separated from the third by a colon. In Chapter 15, “Input and Output Operations in C,” you learn how the scanf() function returns a value that can be tested to determine if the values were entered in the correct format.

After the time has been entered, the program calls the timeUpdate() function, passing along the currentTime() as the argument. The result returned by the function is assigned to the struct time variable nextTime, which is then displayed with an appropriate printf() call.

The timeUpdate() function begins execution by “bumping” the time in now by one second. A test is then made to determine if the number of seconds has reached 60. If it has, the seconds are reset to 0 and the minutes are increased by 1. Another test is then made to see if the number of minutes has now reached 60, and if it has, the minutes are reset to 0 and the hour is increased by 1. Finally, if the two preceding conditions are satisfied, a test is then made to see if the hour is equal to 24; that is, if it is precisely midnight. If it is, the hour is reset to 0. The function then returns the value of now, which contains the updated time, back to the calling routine.

Initializing Structures

Initializing structures is similar to initializing arrays—the elements are simply listed inside a pair of braces, with each element separated by a comma.

To initialize the date structure variable today to July 2, 2015, the statement

struct date today = { 7, 2, 2015 };

can be used. The statement

struct time this_time = { 3, 29, 55 };

defines the struct time variable this_time and sets its value to 3:29:55 a.m. As with other variables, if this_time is a local structure variable, it is initialized each time the function is entered. If the structure variable is made static (by placing the keyword static in front of it), it is only initialized once at the start of program execution. In either case, the initial values listed inside the curly braces must be constant expressions.

As with the initialization of an array, fewer values might be listed than are contained in the structure. So the statement

struct time time1 = { 12, 10 };

sets time1.hour to 12 and time1.minutes to 10 but gives no initial value to time1.seconds. In such a case, its default initial value is undefined.

You can also specify the member names in the initialization list. In that case, the general format is

.member = value

This method enables you to initialize the members in any order, or to only initialize specified members. For example,

struct time time1 = { .hour = 12, .minutes = 10 };

sets the time1 variable to the same initial values as shown in the previous example. The statement

struct date today = { .year = 2015 };

sets just the year member of the date structure variable today to 2015.

Compound Literals

You can assign one or more values to a structure in a single statement using what is known as compound literals. For example, assuming that today has been previously declared as a struct date variable, the assignment of the members of today as shown in Program 8.1 can also be done in a single statement as follows:

today = (struct date) { 9, 25, 2015 };

Note that this statement can appear anywhere in the program; it is not a declaration statement. The type cast operator is used to tell the compiler the type of the expression, which in this case is struct date, and is followed by the list of values that are to be assigned to the members of the structure, in order. These values are listed in the same way as if you were initializing a structure variable.

You can also specify values using the .member notation like this:

today = (struct date) { .month = 9, .day = 25, .year = 2015 };

The advantage of using this approach is that the arguments can appear in any order. Without explicitly specifying the member names, they must be supplied in the order in which they are defined in the structure.

The following example shows the dateUpdate() function from Program 8.4 rewritten to take advantage of compound literals:

// Function to calculate tomorrow's date – using compound literals

struct date dateUpdate (struct date today)
{
struct date tomorrow;
int numberOfDays (struct date d);

if ( today.day != numberOfDays (today) )
tomorrow = (struct date) { today.month, today.day + 1, today.year };
else if ( today.month == 12 ) // end of year
tomorrow = (struct date) { 1, 1, today.year + 1 };
else // end of month
tomorrow = (struct date) { today.month + 1, 1, today.year };


return tomorrow;
}

Whether you decide to use compound literals in your programs is up to you. In this case, the use of compound literals makes the dateUpdate() function easier to read.

Compound literals can be used in other places where a valid structure expression is allowed. This is a perfectly valid, albeit totally impractical example of such a use:

nextDay = dateUpdate ((struct date) { 5, 11, 2004} );

The dateUpdate() function expects an argument of type struct date, which is precisely the type of compound literal that is supplied as the argument to the function.

Arrays of Structures

You have seen how useful the structure is in enabling you to logically group related elements together. With the time structure, for instance, it is only necessary to keep track of one variable, instead of three, for each time that is used by the program. So, to handle 10 different times in a program, you only have to keep track of 10 different variables, instead of 30.

An even better method for handling the 10 different times involves the combination of two powerful features of the C programming language: structures and arrays. C does not limit you to storing simple data types inside an array; it is perfectly valid to define an array of structures. For example,

struct time experiments[10];

defines an array called experiments, which consists of 10 elements. Each element inside the array is defined to be of type struct time. Similarly, the definition

struct date birthdays[15];

defines the array birthdays to contain 15 elements of type struct date. Referencing a particular structure element inside the array is quite natural. To set the second birthday inside the birthdays array to August 8, 1986, the sequence of statements

birthdays[1].month = 8;
birthdays[1].day = 8;
birthdays[1].year = 1986;

works just fine. To pass the entire time structure contained in experiments[4] to a function called checkTime(), the array element is specified:

checkTime (experiments[4]);

As is to be expected, the checkTime function declaration must specify that an argument of type struct time is expected:

void checkTime (struct time t0)
{
.
.
.
}

Initialization of arrays containing structures is similar to initialization of multidimensional arrays. So the statement

struct time runTime [5] =
{ {12, 0, 0}, {12, 30, 0}, {13, 15, 0} };

sets the first three times in the array runTime to 12:00:00, 12:30:00, and 13:15:00. The inner pairs of braces are optional, meaning that the preceding statement can be equivalently expressed as

struct time runTime[5] =
{ 12, 0, 0, 12, 30, 0, 13, 15, 0 };

The following statement

struct time runTime[5] =
{ [2] = {12, 0, 0} };

initializes just the third element of the array to the specified value, whereas the statement

static struct time runTime[5] = { [1].hour = 12, [1].minutes = 30 };

sets just the hours and minutes of the second element of the runTime array to 12 and 30, respectively.

Program 8.6 sets up an array of time structures called testTimes. The program then calls your timeUpdate function from Program 8.5.

In Program 8.6, an array called testTimes is defined to contain five different times. The elements in this array are assigned initial values that represent the times 11:59:59, 12:00:00, 1:29:59, 23:59:59, and 19:12:27, respectively. Figure 8.2 can help you to understand what the testTimesarray actually looks like inside the computer’s memory. A particular time structure stored in the testTimes array is accessed by using the appropriate index number 0–4. A particular member (hour, minutes, or seconds) is then accessed by appending a period followed by the member name.

Figure 8.2 The array testTimes in memory.

For each element in the testTimes array, Program 8.6 displays the time as represented by that element, calls the timeUpdate() function from Program 8.5, and then displays the updated time.

Program 8.6 Illustrating Arrays of Structures