Reference: Kelley & Pohl, Chapter 4 (4.17)

if (a > b) z = a; else z = b;

· The ternary operator ?: may be used thus:

· Thus, our example may be rewritten:

z = (a > b) ? a : b;

· #define MAX(A,B) (((A) > (B)) ? (A) : (B))

· Also, because ?: is an expression, if expr2 or expr3 are of different types, the result is an expression of the highest type. This activity is often called “type promotion.”

· That is, in the code fragment:

Double d = 10.23; Float f = 3.1416; int i = 10; ... x = (d > 0) ? f : i;

· It associates right to left.

· Also, recall that this operator has the semantics that expr1 is evaluated first.

· Then if expr1 is nonzero (true), expr2 is evaluated and that is the value of the conditional expression as a whole.

· Otherwise, expr1 is zero (false), and expr3 is evaluated making it the value of the conditional expression as a whole.

· Consequently, the conditional operator can be used to perform the work of an if-else statement.

· Note that this can quickly get out of hand if you’re not careful…

· Then, the following table illustrates the effect of the conditional operator.

· Exercise: explain why the first expression is an int rather than char

Expression	Equivalent Expr	Value	Type
i==j ? a-1 : b+1	(i==j) ? (a-1) : (b+1)	99	int
j%3==0 ? i+4 : x	((j%3)==0) ? (i+4) : x	7.07	double
j%3 ? i+4 : x	(j%3) != 0 ? (i+4) : x	5.0	double

Comma operator
· When used within an expression, the comma ',' operator, or sequencing operator, is defined thus:
"A pair of expressions separated by a comma is evaluated left to right, and the type and value of the result are the type and value of the right operand."
· The comma operator has the lowest possible precedence (lower than assignment statements).

· The comma operator associates from left to right.

/* call f with two parameters */

b ();

x = (i++, j++, k++);

is exactly equivalent to writing

i++; j++; x = k++;

· Comma operators are commonly used within for loops to initialize more than one looping index, e.g.:

for (i = 0, j = 1, k = 2; i < n; i++, j++, k++) { ... }

int j;

· In general, a semicolon ';' denotes a sequence point, i.e. it is the point at which everything must synch up.

· Up until that point, all subexpressions can be conceptually evaluated in parallel.
Precedence, associativity, and order of evaluation
· Precedence, associativity, and order of evaluation are orthogonal concepts, e.g.,

10 * 20 + 20 / 5 + 15 … ((10 * 20) + (20 / 5)) + 15

· Most operators do not have an order of evaluation specified

· This “underspecification” allows compilers to optimize your code

· Only logical and '&&', logical or '||', the ternary operator '?:', and the comma ',' operator explicitly specify order of evaluation and define sequence points

· Also, note that the ternary operator associates right to left.

x = f () + g ();

x = (f ()) + g ();

· The only way to guarantee order of evaluation is to split this up into several statements

x1 = f ();

x2 = g ();

x = x1 + x2;

· Different results will occur depending on whether ++n is evaluated before or after power(2,n) is evaluated.

· The underlying problem is that we have a potential “race condition”

· Other types of race conditions occur in concurrent programs

The while statement
Reference: Brooks, Chapter 4 (4.4)

• 
  The syntax of a while statement is as follows.
  

• 
  Generally, statement is a compound statement
  

but not

while (++i < LIMIT) do { /* syntax error: do is not allowed */ j = 2 * i + 3; printf ("%d\n", j); }

· In general, given a sequence of statements of the form

while (expression) statement next statement

the first expression is evaluated.

• 
  Whenever you write a while loop, be sure you determine how it will terminate
  
• 
  A common error would be to omit the increment of i
  
• 
  The result would be an endless loop
  
• 
  Another common error is to forget to initialize i before the beginning of the loop
  
• 
  In this case, the behavior is unpredicatable
  

i = 1;

{

factorial = factorial * i;

}
may be rewritten more concisely as follows

i = 1;

factorial *= i++;

i = 1;

factorial *= i;

• 
  The Fibonacci sequence is a sequence of numbers where the current number is the sum of the previous two numbers in the sequence
  
• 
  The first two numbers in the sequence is 1
  
• 
  The next number is 1 + 1 = 2
  
• 
  The next number after that is 1 + 2 = 3
  
• 
  Here are the first 10 numbers of the sequence:
  

1 1 2 3 5 8 13 21 34 55

• 
  Now we write code to generate N Fibonacci numbers and compute their sum
  

prev1 = prev2 = 1; /* first two numbers */

sum = 2; /* sum of the first two numbers */

count = 2; /* calculate 3rd number on */

while (count < N)

{

int curr = prev1 + prev2;

prev1 = prev2; /* advance prev1 */

prev2 = curr; /* advance prev2 */

count++;

• 
  If N=10, how many iterations does this loop execute? What is the final value of count when N=10?
  

• 
  If N=5, what are the final values of curr, sum, prev1, and prev2?
  

· The following example illustrates a case where all of the work is done during the test.

· The while loop read characters one at a time and stops either when it hits end-of-file or when the character is no longer a whitespace character.

· The null statement ; is the body of the loop.

• 
  The syntax of a for statement is as follows.