Home Previous Next

CSC100 :: Lecture Note :: Week 05
Assignments | Code | Handouts | Resources | Email Thurman {Twitter::@compufoo Facebook::CSzero}
{GDT::Bits:: Time  |  Weather  |  Populations  |  Special Dates}

Overview

Assignments:

Code: if.cpp | if2.cpp | calc.cpp | generations.cpp | Age0.cpp {Age1.cpp and NewAge.cpp}
ifcode.cpp | andor.cpp | Age2.cpp [loops] Adder.cpp | f10while.cpp | f10while2.cpp
DoAdder.cpp | f10do.cpp | ForAdder.cpp | f10for.cpp


The if Statement and else Clause

The if is a selection control statement. It is a keyword of the language. It has the following syntax.

   if (EXPR) 
      statement';
   statement'';

   If  EXPR  evaluates to true (i.e. not zero), then  statement'  is
   executed followed by statement''; otherwise,  statement'  is skipped 
   and the flow control of the program jumps to  statement''.

   if (netWorth > 1000000)
      cout << "you are rich (at least money wise)"; 
   netWorth = netWorth * 2;   //let us double our net worth

Typically, there is no semicolon after the if. If there is, then the body of the if is simply a NULL (empty) statement. In many cases, this is a defect with your program (i.e. it is done by accident, not design).

   if (netWorth < 0)
      ;  //do nothing...

If more than one statement needs to be executed when an if EXPR is true, then a compound statement. should be used. A compound statement is a collection of zero or more statements enclosed in braces {}.

Compound statements are terminated by the closing brace } -- not a semicolon.

   if (EXPR) {
      statement';
      statement'';
   }                //note that there is no semicolon
   statement''';

   If EXPR evaluates to true, then both statement' and statement''
   are executed followed by statement'''; otherwise, statement' and
   statement'' are skipped and the flow control of the program jumps
   to statement'''.

   isSuperStar = false;
   bonus = 0;

   ...

   if (battingAvg > 300) {
      isSuperStar = true;
      bonus = 10000;
   }
   number = 55;

Every if statement can have a corresponding else clause which is executed whenever the if is false (i.e. 0). Syntax.

   if (EXPR)
      statement';
   else
      statement'';
   statement''';

   If EXPR is true, then statement' is executed, the else clause is
   skipped and the flow control of the program jumps to statement''';
   otherwise, statement' is skipped, statement'' is executed and
   the flow control of the program jumps to statement'''.

   if (netWorth > 1000000)
      cout << "you are rich (with respect to money)";
   else
      cout << "you are rich in other ways";

An else clause cannot be used without a corresponding if statement. Example.

   int i = 10;

   ...

   else   //not allowed -- there is no if statement
      cout << "this is not legal\n";

The body of an if construct can be any type of statement. Examples.

   if (EXPR) EXPR;      //the body is an expression statement
   if (EXPR) return EXIT_SUCCESS;  //body is a return statement
   if (EXPR) ;          //body is a null statement
   if (EXPR) { }        //body is an empty compound statement
   if (EXPR) if (EXPR)  //body is another if statement

An if statement containing another if is referred to as a nested if. There is no limit to the amount of nesting that can occur. Examples.

   if (EXPR)
      if (EXPR')
         statement';
   statement'';

   If EXPR is true, then EXPR' is evaluated; otherwise,
   flow control jumps to statement''.  If EXPR' is evaluated
   and it evaluates to true, then statement' is executed;
   otherwise, flow control jumps to statement''.

   if (age >= 100)
      if (gender == 'M')
         cout << "old man look at my life";

   if (age >= 100)
      if (gender == 'M')
         if (iq > 120)
            cout << "smart old man look at my life";
   cout << endl;

When using if statements, it is a good programming practice to use indentation to aid readability. The body of an if statement should be indented three or four spaces.

In all cases, each if can have a corresponding else clause.

   if (EXPR)
      if (EXPR')
         statement';
      else
         statement'';
   statement''';

   The top-most  if  does not have an  else  clause, whereas the
   inner-most  if  does.  If EXPR evaluates to false, then
   flow control jumps to statement'''; otherwise, EXPR' is
   evaluated.  If it evaluates to true, then statement' is
   executed; otherwise, statement' is skipped and statement'' is
   evaluated.  Regardless of which statement is executed,
   flow control jumps to statement'''.

Caution is required to make sure that else clauses match up to the correct if construct.

   if (age > 100)
      if (gender == 'M')
         cout << "you are an old man";
      else
         cout << "you are a young person";

   If age is greater than 100, then  if (gender == 'M')  will
   be executed.  If the gender is 'M', then the correct statement
   will print, but if the gender is not 'M', then the 
   "you are a young person" message will print.

   To correct this problem, a compound statement is needed to
   "tie" the  else  clause with the outer-most  if  statement.

   if (age > 100) {
      if (gender == 'M')
         cout << "you are an old man";
   } else
      cout << "you are a young person";
   
   Now if age > 100, then the body of the  if  is executed;
   otherwise, flow control jumps to the  else  clause.

GDT::C++::Code:: Age0.cpp and Age1.cpp and Age2.cpp

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


Logical Operators

Logical operators are used to "connect" expressions. Where relational operators are used to compare two values, logical operators take boolean operands and combine them to form boolean values.

  !   !expr NOT
  &&   expr1 && expr2 AND
  ||   expr1 || expr2 OR

The ! operator is a high-precedence unary operator, while && and || are medium-precedence binary operators. AND has slightly higher precedence than OR.

Examples.

   int i = 10, j = 5, k = 0;

   i == 10 && j == 5     yields the value 1 (true)
   i == 5  && j == 5     yields the value 0 (false)
   i == 10 || j == 5     yields the value 1
   i == 5  || j == 10    yields the value 0
   !i                    yields the value 0
   !k                    yields the value 1
   !k && k               yields the value 0

Given expr1 && expr2, expr1 is evaluated first. If it evaluates to false, then the entire EXPR will be false (0 && anything is 0); therefore, expr2 is not evaluated. This is called short circuit evaluation.

When using the terms true and false, zero is false and not-zero is true.

GDT::C++::Code:: LogicalOps.cpp

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


A Joke Having To Do With Loops

Example of 21st century Informatics?

   Q: How do you keep a computer programmer in the 
      shower all day long?

   A: Give them a shampoo with a label that says 
      "rinse, lather, repeat." 

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The while Statement

The while statement supports iteration (i.e. it is a repetition control statement). Iteration is the process of repeating an operation.

The idea of looping in a computer program can be attributed to Ada Lovelace (01815-01852). Many believe Lovelace wrote the first "computer program." On 10 December 1980 (Ada's birthday), the U.S. Defense Department approved the reference manual for its new computer programming language, called "Ada".

The while statement repeatedly executes a simple statement or block (i.e. compound statement) until a conditional EXPR becomes false (i.e. 0). Each loop iteration is called a cycle.

   while (EXPR)    // typically, you don't want a semicolon 
      statement;

   EXPR is the "conditional" test used to determine whether the loop 
   should continue for another cycle, and  statement  is to be repeated.
   If multiple  statements  need to be executed, then use a compound 
   statement (or block).

   EXPR is evaluated only at the beginning of a loop cycle.

   Pseudo-code for a while loop:
      
      top-of-loop
         evaluate the EXPR
         if  EXPR  is "true"      // i.e. a non-zero value
            execute statement
            go to top-of-loop
         else
            go to end-of-loop  (i.e. terminate the loop)
      end-of-loop
      statement
      ...

   //Example:  loop until user enters a positive number
   int n = -1;
   while (n <= 0)
      cin >> n;

   //Example:  print out the numbers 1 through 5
   int i = 1;
   while (i <= 5) {
      cout << i << endl;
      i = i + 1;
   }
Sentinel Values

One way to terminate (end) a loop is when a particular data value is entered (e.g. the user enters a -1 or end-of-file is encountered), a special value that is used to end the loop is called a sentinel value.

Sentinel values should be defined as manifest (symbolic) constants. Example:

   const int EXIT_VALUE = -1;
   int n = EXIT_VALUE + 1;
   while (n != EXIT_VALUE) {
      cout << "Enter a number (" << EXIT_VALUE << " to exit): ";
      cin >> n;
   }
Infinite Loops

When you use a loop in a program, it is important to make sure that the condition used to control the loop will eventually become false, so that the loop can end. A loop that never finishes is called an infinite loop.

To stop an infinite loop, a special command sequence must be typed on the keyboard to interrupt the program and forcibly cause it to quit. This command differs from machine to machine.

Sometimes infinite loops are used by design; therefore, existenance of an infinite loop does not necessarily imply a program defect.

   // the following are infinite loops that do nothing 
   while (1) 
      ;  //null statement

   int i = 99;
   while (i != 0) ;

   while (true) ;  //C++ only...

   while (!false) { }  //C++ only....

   while (43 == 43) ;

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The do while Statement

The do while statement supports iteration (i.e. it is a repetition control statement). Iteration is the process of repeating an operation.

The do while statement repeatedly executes a simple statement or block (i.e. compound statement) until a conditional EXPR becomes false (i.e. 0). Each loop iteration is called a cycle.

   do 
      statement;
   while (EXPR);  //semicolon must follow the while statement

   EXPR is the "conditional" test used to determine whether the loop 
   should continue for another cycle, and  statement  is to be repeated.
   If multiple  statements  need to be executed, then use a compound 
   statement (or block).  A compound statement is almost always used.

   EXPR is evaluated only at the end of a loop cycle.  

   Pseudo-code for a do-while loop:
      
      top-of-loop
         execute statement
         evaluate the EXPR
         if  EXPR  is "true"      // i.e. a non-zero value
            go to top-of-loop
         else
            go to end-of-loop  (i.e. terminate the loop)
      end-of-loop
      statement
      ...

   //Example:  print out the numbers 1 through 3
   int i = 1;
   do {
      cout << i << endl;
      i = i + 1;
   } while (i <= 3);


   Could the previous loop be rewritten:
      int i = 1;
      do cout << i++ << endl; while (i <= 3);

   How about:
      int i = 1;
      do cout << i << endl; while(i++ <= 3);

When you know for sure that a loop must cycle at least once, then a do-while is a good loop construct to use.

   set item counter to 0
   do {
      prompt user for data
      get data from user
      if (data equals sentinel value)
         break;
      if (data is junk)
         continue;  //get more data from the user
      process the data
      increment the item counter
   } while (1);
   print the item counter
Comment on Style

The do-while can be difficult to read; therefore, to help it "stick" out, I suggest the following.

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The for Statement

The for statement supports iteration (i.e. it is a repetition control statement). Iteration is the process of repeating an operation.

The for statement repeatedly executes a simple statement or block (i.e. compound statement) until a control-EXPR becomes false (i.e. 0). Each loop iteration is called a cycle.

   for ([initialization-step]; [conditional-step]; [increment-step])
      statement;

   The optional "initialization-step" is executed once before the loop 
   is ever executed (and before the "conditional-step" is evaluated
   for the first time).

   The optional "conditional-step" is an EXPR that is evaluated at
   the top of the loop.  If it is true, then the body of the
   for  statement is executed; otherwise, flow control jumps to
   the first executable statement after the  for  loop body.  If
   no conditional-step is specified, then  it is taken as
   permanently true.

   After the body of a  for  loop has been executed, the optional
   "increment-step" is executed.

   After the increment-step is executed; the conditional-step
   is re-evaluated.

   Example:

      //print the numbers 1 through 3

      int i;
      for (i = 1; i <= 3; i = i + 1)
         cout << i << endl;

If the body of the for contains multiple statements, then a compound statement is needed.

All three steps for a for loop are EXPRs. Most commonly, the initialization-step and the increment-step are assignments or functions calls, and the conditional-step is a relational EXPR.

The for is frequently used when there are simple initialization and increment steps because it keeps the loop control statements close together and visible at the top of the loop.

The initialization and increment steps often take advantage of the sequence operator.

   for (i = 0, j = 99; i < n; i = i + 1, j = j - 1)
      do_something;

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The break Statement

The break statement is a jump control statement that is used inside of repetition control statements and the switch selection control statement.

The break statement causes an immediate exit from the innermost enclosing switch or loop statement.

The break statement allows a loop to be exited from some point other than at the top or bottom of the loop.

Structured programming purist are not overly fond of the break statement.

   //
   // enter into an infinite loop reading integers entered by
   // the user... the loop terminates when a sentinel value of
   // -1 is entered... 
   //
   int cnt = 0;
   const int SENTINEL = -1;
   while (1) {
      cout << "Enter an integer (" << SENTINEL << " to exit): ";
      cin >> input;
      if (SENTINEL == input)
         break;  //flow control jumps to the statement A
      cnt = cnt + 1;
      ...
   }
   /*A*/ cout << cnt << " numbers entered" << endl;

You must be careful when you use the break.

   while (...) {
      ...
      if (...) {
         ...
         if (...) 
            break;  // the programmer wants to  break  out of the
                    // body of the enclosing  if  statement,
                    // but instead the  break  will cause the
                    // flow control of the program to jump to
                    // the 1st executable statement after the
                    // body of the  while  statement (/*B*/)
         ...
      }
      /*A*/ ...
   }
   /*B*/ ...

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The continue Statement

The continue statement is a jump control statement that is used inside of repetition control statements.

The continue statement causes the next iteration of the enclosing loop statement to begin. In the while and do this means that the control-EXPR is executed immediately; in the for control passes to the step-EXPR.

The continue statement is often used when the part of the loop that follows is complicated, so that reversing a test and indenting another level would nest the program too deeply.

Structured programming purist are not overly fond of the continue statement.

   while (input != SENTINEL) {
      /* Part A */
      ...

      if (EXPR)
         continue;

      /* Part B */
      ...
   }

      When  if (EXPR)  evaluates to  true,  the  continue  statement
      is executed and the flow control of the program jumps to 
      control expression of the  while  (i.e.  input != SENTINEL)
      is re-evaluated.

Here is the same loop written without using a continue statement.

   while (input != SENTINEL) {
      /* Part A */
      ...

      if (!EXPR) {
         /* Part B */
         ...
      }
   }

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


The goto Statement

The goto statement is a jump control statement that is used to alter the flow control of a program.

Statements can labeled. Label names conform to the naming syntax that is applied to variables. Syntax of a labeled statement.

   some_label_name:  statement;

Statement labels are used with the goto statement.

   goto some_label_name;

When a goto is executed, the flow control of the program immediately jumps to the labeled statement.

Although use of the goto should be minimized, there are a few situations where they may be useful.

   for (EXPR) {
      ...
      for (EXPR) {
         ...
         if (EXPR)
            goto end_of_loops;  /*want to break from both loops*/
         ...
      }
      ...
   }
   end_of_loops:
   ...

An aside: In Java, goto is not a keyword, but it is a reserved word. In addition, to handle the aforementioned example, Java supports labeled break statements.

The goto statement is frequently found in code that is generated by other programs.

If you want to go somewhere, goto is the best way to get there.
-- Ken Thompson (creator of Unix)

Edsger Dijkstra (01930-02002) was a Dutch computer scientist. Dijkstra won the ACM Turing Award in 01972. According to the Wikipedia, Dijkstra was also known for his "low opinion of the GOTO statement in computer programming, culminating in the 1968 article 'A Case against the GO TO Statement', regarded as a major step towards the widespread deprecation of the GOTO statement and its effective replacement by structured control constructs such as the while loop. This methodology was also called structured programming." {Wikipedia.org::Edsger W. Dijkstra}

Update::2016.12.19

{TopOfPage} {Tutorial (text)} {C++ Programming (video)} {C at MIT (course)} {online IDEs: CodingGround | CPP.sh | jdoodle} {GDT::C/C++ Resource}


Home Previous Next