Flow of Control

Boolean Expressions and Operators

C has no boolean type -- it uses integers instead:

• 0 is false
• not 0 is true

/* legal C syntax */
if (1) count++;

Useful constant definitions:

const int TRUE = 1;
const int FALSE = 0;

int b = 7;

if (b == TRUE) count++;

Return to Table of Contents

Relational (Comparison) Operators

C syntax for relational operators

operator	meaning
<	less than
<=	less than or equal
>	greater than
>=	greater than or equal
==	equality
!=	inequality

All about comparisons:

• the operands of these operators can be constants, variables or expressions

  #define PI 3.14
  int y;
  
  if (PI/2 + 34.7 == y) ...
  

• the operands can be of any numeric type (including char)
• mixing of types is allowed

  (3 == 3.0) 
  

  is legal and true (not 0).
• a comparison like:

  (2.0 == 3 * (2.0 / 3.0))
  

  may evaluate to false because of round-off error.
• it is easy to confuse == and =

    if (a=3) count++;
  

  • is legal C syntax
  • looks like an equality test
  • assigns 3 to a
  • is true in this case, because the value of an assignment statement is the value of the expression on the right hand side.
• most C statements that use boolean expressions require that the boolean expression be in parentheses

Return to Table of Contents

Boolean Operators and Compound Boolean Expressions

operator	meaning	example
&&	logical and	((1 <= a) && (a <= 10))
||	logical or	((a == 1) || (a == 2))
!	logical negation	(!(a == 1)) equivalent to (a != 1)

Example: to test whether the value of a double variable d1 is within 0.001 of the value of another double variable d2:

((d1 >= (d2 - 0.001)) && (d1 <= (d2 + 0.001)))

Operators && and || are short circuit - they sometimes don't evaluate their second argument. E.g. let exp be any expression of type int:

(0 && exp) is false
(1 || exp) is true

Short circuit evaluation is often useful. E.g. searching in an array:

  while ((index < MAX) && (A[index] != 3))
    index++;

Return to Table of Contents

if Statements

The if statement is used when a segment of code may or may not be executed, depending on the value of some condition. It has two forms:

if (boolean expression) block

if (boolean expression) block1
else block2

• the boolean expression must be enclosed in parentheses
• each block is a single statement followed by ; or one or more statements (each followed by ;) enclosed in { }
• in the first form, the block is executed if and only if the boolean expression is true (not 0).
• in the second form, block1 is executed if the boolean expression is true, and block2 is executed if the boolean expression is false (0).

E.g.:

  int arg, result;

  /* something gets assigned to arg here */

  /* find absolute value of arg and 
     put it in result */

  if (arg < 0) result = -arg;
  else result = arg;

E.g:

  int arg, result;

  /* something gets assigned to arg here */
  
  /* assign absolute value of arg to arg */

  if (arg < 0) arg = -arg;

  int arg, result;

  /* something gets assigned to arg here */

  /* check if result is set to the 
     absolute value of arg.  If not,
     set it and report the problem. */

  if ((arg < 0) && (result != -arg))
    { printf("result was not set\n");
      result = -arg;
    } 
  else if ((arg >= 0) && (result != arg))
    { printf("result was not set\n");
      result = arg;
    } 

One common error is to forget { } around a block of several statements:

  if (arg < 0)
    printf("arg is negative\n");
    result = -arg;

If statements can contain other if statements. See ~taw2/pub/if.c.

More interesting nesting is also possible. To check if a point falls in either of the intervals:

    int point;

/* A */  if (point <= -1) 
/* B */    if (point >= -2)
             printf("point is in range\n");
/* C */  else if (point >= 1)
           if (point <= 2)
             printf("point is in range\n");
 
/* D */  

    int point;

/* A */  if (point <= -1) 
/* B */    {if (point >= -2)
             printf("point is in range\n");}
/* C */  else if (point >= 1)
           if (point <= 2)
             printf("point is in range\n");
 
/* D */  

Short circuit evaluation can be used with if statements to avoid run-time and logical errors:

  if ((count != 0) && (sum/count > 10))
    sum++;

Return to Table of Contents

if Expressions

An if statement decides which block of code to execute based on the value of a boolean expression. An if expression computes a value based on a boolean expression.

Syntax:

(boolean expr)? expr1:expr2

If boolean expr is true (not 0), this expression has the value of expr1. Otherwise, it has the value of expr2.

E.g.:

  int arg, result;

  result = (arg < 0)?-arg + 3: arg + 3;

An if expression can be used anywhere an expression can be used:

• on the right hand side of an assignment statement
• in a boolean expression
• as an argument to a printf
• ...

E.g.:

  printf("The absolute value is: %d\n",
         (arg < 0)?-arg:arg);

Return to Table of Contents

switch Statements

• like case in Pascal
• decides which of several groups of statements to execute by comparing the value of a variable for equality with several constant values, each associated with on group of statements
• useful for making multiple equality comparisons on a single variable
• only variables of integer types (including char) can be used as the argument of a switch

Syntax of switch:

  switch (variable) {
    case value1: group1
                 break;
    case value2: group2
                 break;

                 .
                 .
                 .

    case valueN: groupN
                 break;
    /* next 2 lines are optional */
    default:     groupD
                 break;
  } /* end switch */

• variable is a variable of some integer type
• each value is a constant that is compared for equality with variable
• each group is 0 or more C statements which need not be in { }

This switch is equivalent to:

  if (variable == value1) {
    group1
  } else if (variable == value2) { 
    group2
  } else 
      .
      .
      .
  
  } else if (variable == valueN) { 
    groupN
  } else {
    groupD
  }

See ~taw2/pub/switch.c.

• if the value of x is 1, 2, or 3 this program prints that many *s.
• if the value of x is anything else, the program prints 4 *s.

The break statement causes following cases to be ignored - "control jumps out of the switch". If we remove all of the break statements from this program, it prints 9 *s for x == 2, because the case for x == 3 and the default case are also executed.

Forgetting break statements is a common cause of errors.

Return to Table of Contents

Loops

• used to execute one or more statements repeatedly
• useful for:
  • reading and processing all items from a file
  • array handling
  • some numeric computations
  • ...

for Loops

• used when the number of repetitions is known in advance
• usually used with a counter or loop control variable

Syntax:

for (initialize counter; boolean expression; change counter) block

• the boolean expression need not be in ( )
• the loop repeats until the boolean expression becomes false
• block is executed on each repitition of the loop
• block is single statement followed by ; or a group of statements in { }
• block may be executed 0 times

E.g. printing the even numbers from 2 to 10:

  int counter;

  for (counter = 2; counter <= 10; counter += 2)
    printf("%d\n", counter);

Note that the counter variable is changed after the block is executed.

E.g. print and sum the odd numbers from 15 to 1

  int counter, sum=0;
  /* initialize sum to 0 */

  for (counter = 15; counter >= 1; counter -= 2) {
    printf("%d\n", counter);
    sum += counter;
  }
  printf("The sum is %d\n", sum);

See ~taw2/pub/ave.c for another example.

Return to Table of Contents

while Loops

while loops are usually used when the number of iterations isn't known in advance (indefinite iteration).

Syntax:

while (boolean expression) block

The boolean expression is re-evaluated at the beginning of each iteration, and the block is executed until the boolean expression becomes false. If the boolean expression is false initially, the block is never executed.

The example program in ~taw2/pub/enternum.c forces the user to enter a number between 1 and 10. Control-C can be used to break out of such a program.

The usual form for a while loop is:

  initialize variables
  while (boolean expression) {
    body (changes some variable
      occurring in the boolean
      expression)
  }

See ~taw2/pub/ave2.c for another example.

Return to Table of Contents

do while Loops

Syntax:

do block while (boolean expression);

The boolean expression is not tested until the "bottom" of the loop, so the block is always executed at least once. See ~taw2/pub/ave3.c for an example.

Each of the three kinds of loops can be used whenever a loop is needed, but each is best suited for certain situations:

• for loops
  • when the number of iterations is known in advance
  • for counting
• while loops - any other time, except when the body of the loop must be executed at least once
• do while loops - when the body of the loop must be executed at least once.

Return to Table of Contents

Using break and exit()

• in a switch statement, a break statement "broke out of the switch" - control jumped past the switch statement
• in a loop, a break statement causes control to jump out of the loop
• using break in this way is poor programming style, so don't do it without a good reason - i.e. in an error situation

See ~taw2/pub/usebreak.c for an example.

When the exit() function is executed, it immediately stops (in UNIX terminology, terminates) the execution of the program. In UNIX:

  exit(0); /* normal termination */
  exit(1); /* or any other nonzero int */
           /* signals error termination */

The value used with exit is assigned to the environment variable status. The value of this variable can be printed:

echo $status

See ~taw2/pub/useexit.c.

Note that:

  for (;;) {
    body
  }

  while (1) (
    body
  }

Return to Table of Contents