you're reading...

C++ Fundamental Control Structures

Flow of Control:

Flow of control through any given function is implemented with three
basic types of control structures:

  • Sequential: default mode. Sequential execution of code statements
    (one line after another) — like following a recipe
  • Selection: used for decisions, branching — choosing between 2 or
    more alternative paths. In C++, these are the types of selection

    • if
    • if/else
    • switch
  • Repetition: used for looping, i.e. repeating a piece of code
    multiple times in a row. In C++, there are three types of loops:

    • while
    • do/while
    • for

The function construct, itself, forms another way to affect flow
of control through a whole program. This will be discussed later in the

Some useful tools for building programs or program

  • pseudocode – helps “think” out a problem or algorithm before trying
    to code it
  • flowcharting – graphical way to formulate an algorithm or a
    program’s flow
  • stepwise refinement (top-down design) of algorithms

True and False

  • Selection and repetition statements typically involve decision steps.
    These steps rely on conditions that are evaluated as true or
  • C++ has a boolean data type (called bool) that has
    values true and false. Improves readability.
  • Most functions that answer a yes/no question (or a true/false
    situation) will return a boolean answer (or in the case of
    user-defined functions, they should be coded that way)
  • Important: ANY C++ expression that evaluates to a value
    (i.e. any R-value) can be interpreted as a true/false condition. The rule

    • If an expression evaluates to 0, its truth value is false
    • If an expression evaluates to non-zero, its truth value is true

Logical Operators:

The arithmetic comparison operators in C++ work much like the symbols we
use in mathematics.  Each of these operators returns a true
or a false.

  x == y        // x is equal to y
  x != y        // x is not equal to y
  x < y         // x is less than y
  x <= y        // x is less than or equal to y
  x > y         // x is greater than y
  x >= y        // x is greater than or equal to y

We also have Boolean operators for combining expressions.  Again,
these operators return true or false

  x && y        // the AND operator -- true if both x and y are true
  x || y        // the OR operator -- true if either x or y (or both) are true
  !x            // the NOT operator (negation) -- true if x is false

These operators will be commonly used as test expressions in selection
statements or repetition statements (loops).


Examples of expressions

  (x > 0 && y > 0 && z > 0)     // all three of (x, y, z) are positive
  (x < 0 || y < 0 || z = 20 && !(classAvg = 20 && classAvg >= 70)
        // means the same thing as the previous expression

Short Circuit Evaluation:

  • The && and || operators also have a feature
    known as short-circuit evaluation.

  • In the Boolean AND expression (X && Y), if X
    is false, there is no need to evaluate Y (so the evaluation
    stops). Example:

      (d != 0 &&  n / d > 0)
      // notice that the short circuit is crucial in this one.  If d is 0,
      //  then evaluating (n / d)  would result in division by 0 (illegal). But
      //  the "short-circuit" prevents it in this case.  If d is 0, the first
      //  operand (d != 0) is false.  So the whole && is false.
  • Similarly, for the Boolean OR operation (X || Y), if the
    part is true, the whole thing is true, so there is no need to continue the
    evaluation. The computer only evaluates as much of the expression as it
    needs. This can allow the programmer to write faster executing code.

Selection Statements

The if/else Selection Statement

  • The most common selection statement is the
    statement. Basic syntax:

       if (expression)
  • The else clause is optional, so this format is also legal:
       if (expression)
  • The expression part can be any expression that evaluates a
    value (an R-value), and it must be enclosed in parintheses ( ).

    • The best use is to make the expression a Boolean
      , which is an operation that evaluates to true
      or false
    • For other expressions (like (x + y), for instance):
      • an expression that evaluates to 0 is considered false
      • an expression that evalautes to anything else (non-zero) is
        considered true
  • The statement parts are the “bodies” of the if-clause and the
    else-clause. The statement after the if or else clause must
    be either:

    • an empty statement
    • a single statement
    • a compound statement (i.e. a block).
      Can enclose multiple code statements. Remember, a compound statement
      is enclosed in set braces { }

  • Appropriate indentation of the bodies of the if-clause and else-clause
    is a very good idea (for human readability), but irrelevant to the


   if (grade >= 68)
      cout << "Passing";

// Notice that there is no else clause.  If the grade is below
68, we move on.

   if (x == 0)
      cout << "Nothing here";
      cout << "There is a value";

// This example contains an else clause.  The bodies are single

   if (y != 4)
      cout << "Wrong number";
      y = y * 2;
      cout << "That's it!";
      success = 1;

Multiple statements are to be executed as a result of the condition
being true or false.  In this case, notice the compound statement
to delineate the bodies of the if and else clauses.

Be careful with ifs and elses.  Here’s an example
of an easy mistake to make.  If you don’t use { }, you may think that
you’ve included more under an if condition than you really

// What output will it produce if val = 2?   Does the “too
bad” statement really go with the “else” here?

   if (val < 5)
      cout << "True\n";
      cout << "False\n";
      cout << "Too bad!\n";

* Indentation is only for people!  It improves readability, but
means nothing to the compiler.

Example links

Some common errors

What’s wrong with these if-statements? Which ones are syntax errors and
which ones are logic errors?

  • if (x == 1 || 2 || 3)
       cout << "x is a number in the range 1-3";
  • if (x > 5) && (y < 10)
       cout << "Yahoo!";
  • if (response != 'Y' || response != 'N')
       cout << "You must type Y or N (for yes or no)";

The switch statement

  • A switch statement is often
    convenient for occasions in which there are multiple cases to
    choose from. The syntax format is:

    switch (expression)
        case constant: 
        case constant: 
        ...  (as many case labels as needed) 
        default:            // optional label 
  • The switch statement evaluates the expression, and then compares
    it to the values in the case labels. If it finds a match, execution
    of code jumps to that case label.
  • The values in case labels must
    be constants, and may only be integer types, which means that you

    • This means only integer types, type char, or enumerations
      (not yet discussed)
    • This also means the case label must be a literal or a
      variable declared to be const
    • Note: You may not have case labels with regular
      variables, strings, floating point literals, operations, or function
  • If you want to execute code only in the case that you jump to,
    end the case with a break statement, otherwise execution of
    code will “fall through” to the next case
  • Examples:
    • Recall this
      — an if/else structure to determine a letter grade
    • Switch Example 1
      — An attempt to convert the letter grade example into a switch.
      Syntactically correct, but has a logic flaw. What is it?
    • Switch Example 2
      — corrected version of Example 1
    • Switch Example 3
      — Uses a switch statement to process a menu selection, using both
      upper and lower case options


The Conditional Operator

There is a special operator known as the conditional operator that
can be used to create short expressions that work like if/else

  • Format:
      test_expression ? true_expression : false_expression
  • How it works:
    • The test_expression is evaluated for true/false value. This
      is much like the test expression of an if-statement
    • If the test expression is true, the operator returns the
    • If the test expression is false, the operator returns the
  • Note that this operator takes three operands. It is the one
    ternary operator in the C++ language
  • Example 1:
      cout << (x > y ? "x is greater than y" : "x is less than or equal to y");
      // Note that this expression gives the same result as the following
      if (x > y)
         cout << "x is greater than y";
         cout << "x is less than or equal to y";
  • Example 2:
      (x < 0 ? value = 10 : value = 20);
      // this gives the same result as:
      value = (x < 0 ? 10 : 20);
      // and also gives the same result as:
      if (x < 0)
         value = 10;
         value = 20;


Repetition Statements

  • Repetition statements are called loops, and are used to repeat
    the same code mulitple times in succession. How many times is based on
    criteria defined in the loop structure
  • The three loop structures in C++ are while, do/while,
    and for loops. We’ll start with the simplest ones here
    (while, do/while).
  • Format of while loop:
     while (expression) 
  • Format of do/while loop:
     while (expression); 
  • The expression in these formats is handled
    the same as in the if/else statements discussed above
  • The “statement” portion is also as in if/else.
    It can be a single statement or a compund statement (a block { } ).
  • We could also write the formats as follows (illustrating more visually
    what they look like when a compound statement makes up the loop “body”):

     // while loop format
     while (expression) 
        // ...
     // do-while loop format
        // ...
     } while (expression);
    • The expression is a test condition that is evaluated to decide
      whether the loop should repeat or not.

      • true means run the loop body again.
      • false means quit.
    • The while and do/while loops both follow the same
      basic flowchart — the only exception is that:

      • In a while loop, the expression is tested first
      • In a do/while loop, the loop “body” is executed first


Both of the following loops add up all of the numbers between 1 and 50.

 // while loop example 
 // loop body runs 50 times, condition checked 51 times 
 int i = 1, sum = 0; 
 while (i <= 50) 
    sum += i;		// means:  sum = sum + i; 
    i++; 		// means:  i = i + 1;
 cout << "Sum of numbers from 1 through 50 is " << sum; 

 // do/while loop example 
 // loop body runs 50 times, condition checked 50 times 
 int i = 1, sum = 0; 
    sum += i;		// means:  sum = sum + i; 
    i++; 		// means:  i = i + 1;
 } while (i <= 50); 
 cout << "Sum of numbers from 1 through 50 is " << sum; 


No comments yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: