[FrontPage] [TitleIndex] [WordIndex]

Note: You are looking at a static copy of the former PineWiki site, used for class notes by James Aspnes from 2003 to 2012. Many mathematical formulas are broken, and there are likely to be other bugs as well. These will most likely not be fixed. You may be able to find more up-to-date versions of some of these notes at http://www.cs.yale.edu/homes/aspnes/#classes.

The bodies of C functions (including the main function) are made up of statements. These can either be simple statements that do not contain other statements, or compound statements that have other statements inside them. Control structures are compound statements like if/then/else, while, for, and do..while that control how or whether their component statements are executed.

1. Simple statements

The simplest kind of statement in C is an expression (followed by a semicolon, the terminator for all simple statements). Its value is computed and discarded. Examples:

```   1     x = 2;              /* an assignment statement */
2     x = 2+3;            /* another assignment statement */
3     2+3;                /* has no effect---will be discarded by smart compilers */
4     puts("hi");         /* a statement containing a function call */
5     root2 = sqrt(2);    /* an assignment statement with a function call */
```

Most statements in a typical C program are simple statements of this form.

Other examples of simple statements are the jump statements return, break, continue, and goto. A return statement specifies the return value for a function (if there is one), and when executed it causes the function to exit immediately. The break and continue statements jump immediately to the end of a loop (or switch; see below) or the next iteration of a loop; we'll talk about these more when we talk about loops. The goto statement jumps to another location in the same function, and exists for the rare occasions when it is needed. Using it in most circumstances is a sin.

2. Compound statements

Compound statements come in two varieties: conditionals and loops.

2.1. Conditionals

These are compound statements that test some condition and execute one or another block depending on the outcome of the condition. The simplest is the if statement:

```   1     if(houseIsOnFire) {
2         /* ouch! */
3         scream();
4         runAway();
5     }
```

The body of the if statement is executed only if the expression in parentheses at the top evaluates to true (which in C means any value that is not 0).

The braces are not strictly required, and are used only to group one or more statements into a single statement. If there is only one statement in the body, the braces can be omitted:

```   1     if(programmerIsLazy) omitBraces();
```

This style is recommended only for very simple bodies. Omitting the braces makes it harder to add more statements later without errors.

```   1     if(underAttack)
2         launchCounterAttack();   /* executed only when attacked */
3         hideInBunker();          /* ### DO NOT INDENT LIKE THIS ### executed always */
```

In the example above, the lack of braces means that the hideInBunker() statement is not part of the if statement, despite the misleading indentation. This sort of thing is why I generally always put in braces in an if.

An if statement may have an else clause, whose body is executed if the test is false (i.e. equal to 0).

```   1     if(happy) {
2         smile();
3     } else {
4         frown();
5     }
```

A common idiom is to have a chain of if and else if branches that test several conditions:

```   1     if(temperature < 0) {
2         puts("brrr");
3     } else if(temperature < 100) {
4         puts("hooray");
5     } else {
6         puts("ouch!");
7     }
```

This can be inefficient if there are a lot of cases, since the tests are applied sequentially. For tests of the form <expression> == <small constant>, the switch statement may provide a faster alternative. Here's a typical switch statement:

```   1     /* print plural of cow, maybe using the obsolete dual number construction */
2     switch(numberOfCows) {
3     case 1:
4         puts("cow");
5         break;
6     case 2:
7         puts("cowen");
8         break;
9     default:
10         puts("cows");
11         break;
12     }
```

This prints the string "cow" if there is one cow, "cowen" if there are two cowen, and "cows" if there are any other number of cows. The switch statement evaluates its argument and jumps to the matching case label, or to the default label if none of the cases match. Cases must be constant integer values.

The break statements inside the block jump to the end of the block. Without them, executing the switch with numberOfCows equal to 1 would print all three lines. This can be useful in some circumstances where the same code should be used for more than one case:

```   1     switch(c) {
2     case 'a':
3     case 'e':
4     case 'i':
5     case 'o':
6     case 'u':
7         type = VOWEL;
8         break;
9     default:
10         type = CONSONANT;
11         break;
12     }
```

or when a case "falls through" to the next:

```   1     switch(countdownStart) {
2     case 3:
3         puts("3");
4     case 2:
5         puts("2");
6     case 1:
7         puts("1")
8     case 0:
9         puts("KABLOOIE!");
10         break;
11     default:
12         puts("I can't count that high!");
13         break;
14     }
```

Note that it is customary to include a break on the last case even though it has no effect; this avoids problems later if a new case is added. It is also customary to include a default case even if the other cases supposedly exhaust all the possible values, as a check against bad or unanticipated inputs.

```   1     switch(oliveSize) {
2     case JUMBO():
3         eatOlives(SLOWLY);
4         break;
5     case COLLOSSAL:
6         eatOlives(QUICKLY);
7         break;
8     case SUPER_COLLOSSAL:
9         eatOlives(ABSURDLY);
10         break;
11     default:
12         /* unknown size! */
13         abort();
14         break;
15     }
```

Though switch statements are better than deeply nested if/else-if constructions, it is often even better to organize the different cases as data rather than code. We'll see examples of this when we talk about function pointers C/FunctionPointers.

Nothing in the C standards prevents the case labels from being buried inside other compound statements. One rather hideous application of this fact is Duff's device.

2.2. Loops

There are three kinds of loops in C.

2.2.1. The while loop

A while loop tests if a condition is true, and if so, executes its body. It then tests the condition is true again, and keeps executing the body as long as it is. Here's a program that deletes every occurence of the letter e from its input.

```   1 #include <stdio.h>
2
3 int
4 main(int argc, char **argv)
5 {
6     int c;
7
8     while((c = getchar()) != EOF) {
9         switch(c) {
10         case 'e':
11         case 'E':
12             break;
13         default:
14             putchar(c);
15             break;
16         }
17     }
18
19     return 0;
20 }
```

Note that the expression inside the while argument both assigns the return value of getchar to c and tests to see if it is equal to EOF (which is returned when no more input characters are available). This is a very common idiom in C programs. Note also that even though c holds a single character, it is declared as an int. The reason is that EOF (a constant defined in stdio.h) is outside the normal character range, and if you assign it to a variable of type char it will be quietly truncated into something else. Because C doesn't provide any sort of exception mechanism for signalling unusual outcomes of function calls, designers of library functions often have to resort to extending the output of a function to include an extra value or two to signal failure; we'll see this a lot when the null pointer shows up in C/Pointers.

2.2.2. The do..while loop

The do..while statement is like the while statement except the test is done at the end of the loop instead of the beginning. This means that the body of the loop is always executed at least once.

Here's a loop that does a random walk until it gets back to 0 (if ever). If we changed the do..while loop to a while loop, it would never take the first step, because pos starts at 0.

```   1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4
5 int
6 main(int argc, char **argv)
7 {
8     int pos = 0;       /* position of random walk */
9
10     srandom(time(0));  /* initialize random number generator */
11
12     do {
13         pos += random() & 0x1 ? +1 : -1;
14         printf("%d\n", pos);
15     } while(pos != 0);
16
17     return 0;
18 }
```
random_walk.c

The do..while loop is used much less often in practice than the while loop. Note that it is always possible to convert a do..while loop to a while loop by making an extra copy of the body in front of the loop.

2.2.3. The for loop

The for loop is a form of SyntacticSugar that is used when a loop iterates over a sequence of values stored in some variable (or variables). Its argument consists of three expressions: the first initializes the variable and is called once when the statement is first reached. The second is the test to see if the body of the loop should be executed; it has the same function as the test in a while loop. The third sets the variable to its next value. Some examples:

```   1     /* count from 0 to 9 */
2     for(i = 0; i < 10; i++) {
3         printf("%d\n", i);
4     }
5
6     /* and back from 10 to 0 */
7     for(i = 10; i >= 0; i--) {
8         printf("%d\n", i);
9     }
10
11     /* this loop uses some functions to move around */
12     for(c = firstCustomer(); c != END_OF_CUSTOMERS; c = customerAfter(c)) {
13         helpCustomer(c);
14     }
15
16     /* this loop prints powers of 2 that are less than n*/
17     for(i = 1; i < n; i *= 2) {
18         printf("%d\n", i);
19     }
20
21     /* this loop does the same thing with two variables by using the comma operator */
22     for(i = 0, power = 1; power < n; i++, power *= 2) {
23         printf("2^%d = %d\n", i, power);
24     }
25
26     /* Here are some nested loops that print a times table */
27     for(i = 0; i < n; i++) {
28         for(j = 0; j < n; j++) {
29             printf("%d*%d=%d ", i, j, i*j);
30         }
31         putchar('\n');
32     }
```

A for loop can always be rewritten as a while loop.

```   1     for(i = 0; i < 10; i++) {
2         printf("%d\n", i);
3     }
4
5     /* is exactly the same as */
6
7     i = 0;
8     while(i < 10) {
9         printf("%d\n", i);
10         i++;
11     }
```

2.2.4. Loops with break, continue, and goto

The break statement immediately exits the innermmost enclosing loop or switch statement.

```   1     for(i = 0; i < n; i++) {
2         openDoorNumber(i);
3         if(boobyTrapped()) {
4             break;
5         }
6     }
```

The continue statement skips to the next iteration. Here is a program with a loop that iterates through all the integers from -10 through 10, skipping 0:

```   1 #include <stdio.h>
2
3 /* print a table of inverses */
4 #define MAXN (10)
5
6 int
7 main(int argc, char **argv)
8 {
9     int n;
10
11     for(n = -MAXN; n <= MAXN; n++) {
12         if(n == 0) continue;
13         printf("1.0/%3d = %+f\n", n, 1.0/n);
14     }
15
16     return 0;
17 }
```
inverses.c

Occasionally, one would like to break out of more than one nested loop. The way to do this is with a goto statement.

```   1     for(i = 0; i < n; i++) {
2         for(j = 0; j < n; j++) {
3             doSomethingTimeConsumingWith(i, j);
4             if(checkWatch() == OUT_OF_TIME) {
5                 goto giveUp;
6             }
7         }
8     }
9 giveUp:
10     puts("done");
```

The target for the goto is a label, which is just an identifier followed by a colon and a statement (the empty statement ; is ok).

The goto statement can be used to jump anywhere within the same function body, but breaking out of nested loops is widely considered to be its only genuinely acceptable use in normal code.

2.3. Choosing where to put a loop exit

Choosing where to put a loop exit is usually pretty obvious: you want it after any code that you want to execute at least once, and before any code that you want to execute only if the termination test fails.

If you know in advance what values you are going to be iterating over, you will most likely be using a for loop:

```   1 for(i = 0; i < n; i++) {
2     a[i] = 0;
3 }
```

Most of the rest of the time, you will want a while loop:

```   1 while(!done()) {
2     doSomething();
3 }
```

The do..while loop comes up mostly when you want to try something, then try again if it failed:

```   1 do {
2     result = fetchWebPage(url);
3 } while(result == 0);
```

Finally, leaving a loop in the middle using break can be handy if you have something extra to do before trying again:

```   1 for(;;) {
2     result = fetchWebPage(url);
3     if(result != 0) {
4         break;
5     }
6     /* else */
7     fprintf(stderr, "fetchWebPage failed with error code %03d\n", result);
8     sleep(retryDelay);  /* wait before trying again */
9 }
```

(Note the empty for loop header means to loop forever; while(1) also works.)

2014-06-17 11:57