Control

• Basic operators
  • Arithmetic operators
    • Binary +, -, *, /, %, and unary + and -. Precedence and associativity to be discussed later.
    • The libm.a library has maths functions, prototyped in math.h.
  • Relational and logical operators.
    • Relational >, >=, <, <=, ==, !=. These have lower precedence than arithmetic operators.
    • Logical connectives &&, ||. Expressions connected by these are evaluated left to right. Thus in

      for (Index = 0; Index < STRING_LENGTH-1 && (C1=getchar()) != '\n' && C1 != EOF; Index++) {
          MyString[Index]=C1;
      } 

      the order is useful in that it's necessary to check there is space to store the character before reading it. If not the evaluation will stop before the getchar().
    • Unary negation ! which convertes non-0 (true) operands into 0 and a 0 (false) operand into 1.
  • Increment and decrement.
    • ++ and -- can be prefix or postfix. If used prefix the increment/decrement takes place before the variable is used, and if postfix the increment/decrement takes place after the variable is used.
    • SqueezeThis.c - Program that squeezes a string
  • Bitwise logical operators
    • These may be applied to char, short, int, long (signed or unsigned).
    • & = bitwise AND. Useful for masking off bits.
    • | = bitwise inclusive OR. Useful for turning on bits.
    • ^ = bitwise exclusive OR.
    • << = left shift. This shifts the bits of the left operand left by the number of bit positions specified by the right operand, filling the lsbs with zero. Useful for creating masks.
    • >> = right shift. See <<, but fill depends on whether or not sign extension is used for "-ve" bit patterns.
    • ~ = one's complement, i.e. inverts all bits.
    • PlayBits.c - Program that plays with bits

• Precedence and order of evaluation.

  Operator	Associativity
  () func() [] -> .	left to right
  ! ~ ++ -- + - (<type>) * & sizeof	right to left
  * / %	left to right
  + -	left to right
  << >>	left to right
  < <= > >=	left to right
  == !=	left to right
  &	left to right
  ^	left to right
  |	left to right
  &&	left to right
  ||	left to right
  ?:	right to left
  = <operator>=	right to left
  ,	left to right

  • The level 2 + and - operators are unary plus and minus while the level 4 + and - are binary.
  • The level 2 * and & operators are for address arithmetic while the level 3 * is multiplication and the level 8 & is bitwise AND.
  • The associativity specifies the natural bracketing of expressions using the same operator repeatedly. e.g.,

    <expression1> || <expression2> || <expression3> 

    is seen as

    (<expression1> || <expression2>) || <expression3> 

    while

    <variable1> += <variable2> += <expression1> 

    is seen as

    <variable1> += (<variable2> += <expression1>) 

  • The order of evaluation of operands of an operator (except &&, ||, ?:, and ,) is unspecified. To force a particular order temporary variables should be used.
  • The order of evaluation of of operands in an expression and arguments to functions is not specified. To force an order temporary variables should be used.

• Funky expressions
  • Assignment operators and expressions.
    • Expressions of the form

      <variable> = <variable> <operation> <expression> 

      can be rewritten in the form
      

      <variable> <operation>= <expression> 

      if <operation> is one of +, -, *, /, %, <<, >>, &, ^, |.
    • This is great if the variable is very complex.
  • Conditional expressions.
    • Statements of the form

      if (<expression1>)
          <variable> = <expression2>;
      else <variable> = <expression3>; 

      can be rewritten in the form

      <variable> = <expression1> ? <expression2> : <expression3> 

    • The ?: operator contructs genuine expressions, which may be used like any other expression.
    • If <expression2> and <expression3> are of different types the result is determined by the mixed expression conversion rules.
  • FunkyExpressions.c - Program that uses funky expressions
  • Multiple expressions.
    • A pair of expressions separated by a comma is an expression. They are evaluated left-to-right and have the value of the right expression.
    • These appear most frequently in for loops. See later.
    • Beware confusion with other ,s, such as in actual arguments. () should be used to avoid abiguity.

• Statements and Blocks.
  • An expression such as assignment, function call etc becomes a statement when it is followed by a semi-colon. The semi-colon is a statement terminator.
  • {} brackets are used to group statements into compound statements, or blocks.

• Selection statements
  • If and If-else

    if (<expression>) {
        <true stuff>
    }
    
    if (<expression>) {
        <true stuff>
    } else {
        <false stuff>
    } 

    • The test is on the numeric value of the expression. 0 = FALSE; non-0 = TRUE.
    • The hanging-else problem may occur.
  • Switch.
    • SwitchChar.c - Using switch to act according to character.
    • The switch searches for a label corresponding to the switch value and starts execution there.
    • The break is used to exit from the switch, otherwise all statements below the start of execution would be executed (called fall-through). Put break after the last case, even though it is not necessary - it makes it easier to add another case later.
    • The default case is optional, and will execute if no other case is selected.
    • The case labels must be constant and unique, and can only be of integral type.

• Loops
  • For loops

    for (<exp1>;<exp2>;<exp3>) {
        <statement>
    } 

    • Any of the three expressions of a for loop may be omitted. Omitting <exp2> makes the condition TRUE always.
    • The limits and controlling variable may be altered within a for loop but it is bad style.
    • The controlling variable retains its value after the loop is exited.
    • The comma operator appears in <exp1> and <exp3> when more than one variable needs to be initialised or updated.
    • Compound statements are used for clarity and survival
    • ReverseString.c - Program that reverses a string in place
  • While loops

    <exp1>
    while (<exp2>) {
        <statement>
        <exp3>;
    } 

    • There is an equivalence between for and while loops.

      for (<exp1>;<exp2>;<exp3>) {
          <statement>
      } 

  • Do-while loops
    • NumberToString.c - Program that converts an integer to a string
    • Compound statements are used for clarity and survival

• Uncontrolled loops
  • Continue
    • Causes the rest of the body of a for, while or do loop not to be executed.
    • Continue.c - Program that sums the positive numbers input
    • Simple cases are better implemented with if-else.
  • Break
    • BreakLoop.c - Using break to exit a loop
    • Used to exit from for, while, do and switch. The only structured use is in the switch statement.

• Exit

  if (<everything went ok>) {
      exit(EXIT_SUCCESS);
  } else {
      exit(EXIT_FAILURE);
  } 

  • This closes any open files (see later) and exits the program to the parent process (operating system usually) and returns the return value.
  • 0 is usually used for normal termination, non-0 for error.
  • This is actually based on a UNIX system call, but implemented appropriately in other systems.

• Goto's and Labels.

  for (   )
      for (    )
          for (    )
              if (disaster)
                  goto error;
      .........
  error:    /*----Sort out the mess */ 

  • The goto <label> can be used to jump directly to a label.
  • A label is an identifier followed by a colon.
  • Not a good thing - only real use is in error situations.

Exercises

• Write void squeeze(char s1[],char s2[]), that deletes each character in s1 that matches any character in s2.
  Answer: Squeeze.c
• Write char lower(char c1) which returns the lower case of c1, using a conditional expression to test for that case of c1.
• Write void expand(char s1[],char s2[]) which converts non-printing characters (such as new line, tab, etc) in s1 to visible sequences (such as \n, \t, etc) in s2. Use a switch to select the visible sequence for each non-printing character.
• Write int invert(unsigned input,int position,int number) that returns the input value with the number bits that begin at position (counting from the right), inverted. Other bits should be left unchanged.
  Answer: InvertBits.c
• Write void itob(int number,char s1[],int base) that converts the number to a character string in the base. For example itob(i1,s1,16) puts i1 in hex format into s1.
• Exercise 12306
  Given as input three integers representing a date as day, month, year, print out the number day, month and year for the following day's date. Typical run:

  28 2 1992
  Date following 28:02:1992 is 29:02:1992
       

• Write a program which reads two integer values. If the first is less than the second, print the message "up". If the second is less than the first, print the message "down". If the numbers are equal, print the message "equal". If there is an error reading the data, print a message containing the word Error and perform exit(0);
• Exercise 12327
  Write a program to read in 10 numbers and compute the average, maximum and minimum values.
• Exercise 12328
  Write a program to read in numbers until the number -999 is encountered. The sum of all number read until this point should be printed out.
• Exercise 12329
  Write a program which will read an integer value for a base, then read a positive integer written to that base and print its value. Read the second integer a character at a time; skip over any leading non-valid (i.e. not a digit between zero and "base-1") characters, then read valid characters until an invalid one is encountered.

             Input       Output
          ==========     ======
          10    1234      1234
           8      77        63   (the value of 77 in base 8, octal)
           2    1111        15   (the value of 1111 in base 2, binary)
       

  The base will be less than or equal to 10.
• Read in three values representing respectively a capital sum (integer number of cents), a rate of interest in percent (float), and a number of years (integer). Compute the values of the capital sum with compound interest added over the given period of years. Each year's interest is calculated as

  interest = capital * interest_rate / 100;

  and is added to the capital sum by

  capital += interest;

  Print out money values as dollars (cents / 100.0) accurate to two decimal places. Print out a floating value for the value with compound interest for each year up to the end of the period. Print output year by year in a form such as:

  Original sum 30000.00 at  12.5 percent for 20 years
  
  Year Interest  Sum
  ----+-------+--------
    1  3750.00 33750.00
    2  4218.75 37968.75
    3  4746.09 42714.84
    4  5339.35 48054.19
    5  6006.77 54060.96
    6  6757.62 60818.58
    7  7602.32 68420.90
    8  8552.61 76973.51
    9  9621.68 86595.19
   10 10824.39 97419.58
       

• Read a positive integer value, and compute the following sequence: If the number is even, halve it; if it's odd, multiply by 3 and add 1. Repeat this process until the value is 1, printing out each value. Finally print out how many of these operations you performed. Typical output might be:

   Inital value is 9
   Next value is  28
   Next value is  14
   Next value is   7
   Next value is  22
   Next value is  11
   Next value is  34
   Next value is  17
   Next value is  52
   Next value is  26
   Next value is  13
   Next value is  40
   Next value is  20
   Next value is  10
   Next value is   5
   Next value is  16
   Next value is   8
   Next value is   4
   Next value is   2
   Final value 1, number of steps 19
       

  If the input value is less than 1, print a message containing the word Error and perform an exit(0);.
• Write a program to count the vowels and letters in free text given as standard input. Read text a character at a time until you encounter end-of-data. Then print out the number of occurrences of each of the vowels a, e, i, o and u in the text, the total number of letters, and each of the vowels as an integer percentage of the letter total. Suggested output format is:

  Numbers of characters:
  a   3 ; e   2 ; i   0 ; o   1 ; u   0 ; rest  17
  Percentages of total:
  a  13%; e   8%; i   0%; o   4%; u   0%; rest  73%
       

  Read characters to end of data using a construct such as

  char ch;
  while ((ch = getchar()) >= 0) {
  /* ch is the next character */    
      ....
  }
       

  to read characters one at a time using getchar() until a negative value is returned.
• Read a file of English text, and print it out one word per line, all punctuation and non-alpha characters being omitted. For end-of-data, the program loop should read until getchar delivers a value <= 0. When typing input, end the data by typing the end-of-file character, usually control-D. When reading from a file, getchar will deliver a negative value when it encounters the end of the file. Typical output might be

  Read
  a
  file
  of
  English
  text
  and
  print
  it
  out
  one
       

Exam Style Questions

• Any of the short exercises.
• What is the output from the following code segment?

  int i1 = 27;
  int i2 = 29;
  
  if (i1++ >=  --i2) {
      i1++;
      printf("%d %d\n",i1++,i2--);
  } else {
      i2++;
      printf("%d %d\n",--i1,++i2);
  }
  printf("%d %d\n",i1,i2); 

• Assuming that the bits in an integer are numbered from 0, from right (least significant) to left (most significant), write an expression using bitwise logical operators to extract the 4 bits numbered 6 to 3 from an integer i1, and shift them all down so that bit numbered 3 ends up in position number 1.
• Explain how a conditional expression may be rewritten using an if-then-else statement.
• Rewrite the following for loop as a while loop.i

  for (Index = 1;Index < MAX;Index++) {
      printf("%d\n",Index);
      Total += Index;
  } 

• Rewrite the following while loop as a for loop.

  Index = 1;
  while (Index < MAX) {
      printf("%d\n",Index);
      Total += Index;
      Index++;
  } 

• Explain the difference between continue and break statements.
• What is the output from the following code segment?

      Index = 1;
      while (Index < 30) {
          if (Index % 2 == 0) {
              Index = Index < 10 ? ++Index : Index +3;
              continue;
          }
          Index = (Index << 1) + 1;
          if (Index % 6 == 0) {
              break;
          }
          printf("%d\n",Index);
      }