Conditional and Control Statements in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand how to use conditional and control statements in C++
Demonstrate the ability to use conditional and control statements in C++

Conditional Statements

Conditional Statements (1)

Recap:
- A basic form of making a decision using a selection structure
  - the result will return either 1 (true) or 0 (false)
C++ allows the following types of conditional statementS:
- if
- if ... else ...
- if ... else if ....
- nested if ... else ...
These statements are structured slightly different compared to Python

Before we begin delving into the depths of how C++ conditional statements are structured. It would be best to revisit your knowledge that you should have acquired during the first year programming module.

A conditional statement is considered to be a basic decision statement which is structured in a way that it is similar to a ‘selection’. The decision that is made will be described to the Python interpreter as a conditional statement, whereby the outcome will be either True or False.

When it comes to using conditional statements in Python, there are four methods:

a basic if statement, which checks whether something is True
an if ... else ... statement, which checks whether something is True or False
an if ... elif ... else ... statement, which can check a condition has mean met twice, otherwise it will return as False
and finally, the nested if ... else ... statements, which can check whether a condition has met and perform some more checks upon them.

Over the next few slides, we shall be looking at each one of these types of conditional statements, and explore how they work with an example.

`if` Statements

`if` Statements (1)

Often referred to as a decision-making statement
Used to control the flow of execution for statements and to test an expression
- tests logically whether a condition is true or false
Note: Unlike Python the comparison expression is wrapped in brackets (())
- there are also curly brackets ({}) which enclose the return statement

if (variable == value) {
    ...
}

The first conditional statement method we shall be looking at is the if statement. As you will be aware, these are often referred to as a decision-making statement, and it can be used to control the flow of execution for your code or for testing an expression that consists of either a comparison and/or a logical operator.

The tests that performed are logical and can only return one of two values: 1 or 0, where 1 represents true and 0 represents false. However, that does not necessarily mean that these are the values that are returned to the user. They could potentially return strings, integers or different data types, depending upon the outcome that you are expecting.

On the screen is the structure of an if statement. In this example, we are using the is the same operator, which is two equals operators to determine whether the value inside a variable is the same as given value. The three dots in this example is a placeholder for where some code will be placed if this condition was to evaluate to true.

But what would happen if this condition was to evaluate to false? Well, in this instance, nothing would happen. If there was some code directly proceeding after this, and it was not sitting within the conditional statement, it would be executed as normal.

`if` Statements (2)

Example: `if` Statement i

Declare a variable ifExample1 to store the integer value 1
Perform a comparison check: iseXample1 equal to 1?
- if true: print the value True, ifExample1 is 1 to the screen

#include <iostream>
int ifExample1 = 1;
int main() {
  if (ifExample1 == 1) {
    std::cout << "True, ifExample1 is 1" << std::endl;
  }
  return 0;
}

True, ifExample1 is 1

`if` Statements (3)

Example: `if` Statement ii

Declare a variable ifExample1 to store the integer value 2
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value True to the screen
- otherwise, continue executing the code

#include <iostream>
int ifExample1 = 2;
int main() {
  if (ifExample1 == 1) {
    std::cout << "True, ifExample1 is 1" << std::endl;
  }
  std::cout << "Outside the 'if' statement." << std::endl;
  return 0;
}

Outside the 'if' statement.

The second example for an if statement is a little different. Instead, with this example, I want to purposefully fail the condition check to explore what happens if we do fail.

In this example, we have changed the value of our ifExample1 variable to an integer number, two. Our condition check will remain the same, and we shall check whether ifExample1 is equal to the integer number, one. If it is, then we are going to print the value true, ifExample1 is 1 to the screen.

However, preceding that is another print statement. When the script is executed, you can see that the true value is not printed to the screen. However, the secondary print statement has been executed, and the text Outside the "if" statement has been printed to the screen. No matter, if the condition was to evaluate to true or to false our code will always precede forward to the next available line, so long as it is not indented to be within the if statement itself.

`if else` Statements

`if else` Statements (1)

Known as an alternative execution, whereby there are two possibilities
- the condition statement determines which of the two statements gets executed
The else is used as the ultimate result for a test expression
- this result is only met if all other statements are false

if (variable == value) {
  ...
} else {
  ...
}

The next type of conditional statement we shall be looking at, is the if..else statement, otherwise known as an “alternative execution” statement. In this instance, if a condition statement does not evaluate to true, then we can perform some other kind of operation instead.

The condition statement used in this check will determine which of the two statements will be executed. If a condition is evaluated as true, then one operation will be performed, otherwise if the condition is evaluated to false, then we shall move onto the else clause and an alternative operation will be performed.

On the screen is the structure of an if ... else ... statement. In this example, we are using the is the same operator, to determine whether the value inside a variable is the same as given value. The three dots in this example is a placeholder for where some code will be placed if this condition was to evaluate to true. After this, we can see that the else keyword has been introduced. This is our fallback keyword and will only be executed if the conditional check was to evaluate to false.

`if else` Statements (2)

Example: `if else` Statement i

Declare a variable ifExample1 to store the integer value 1
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value True, ifExample1 is 1 to the screen
- otherwise, print False, ifExample1 is not 1

#include <iostream>
int ifExample1 = 1;
int main() {
  if (ifExample1 == 1) {
    std::cout << "True, ifExample1 is 1" << std::endl;
  } else {
    std::cout << "False, ifExample1 is not 1" << std::endl;
  }
  return 0;
}

True, ifExample1 is 1

`if else` Statements (3)

Example: `if else` Statement ii

Declare a variable ifExample1 to store the integer value 2
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value True, ifExample1 is 1 to the screen
- otherwise, print False, ifExample1 is not 1

#include <iostream>
int ifExample1 = 2;
int main() {
  if (ifExample1 == 1) {
    std::cout << "True, ifExample1 is 1" << std::endl;
  } else {
    std::cout << "False, ifExample1 is not 1" << std::endl;
  }
  return 0;
}

`else if` Statements

`else if` Statements (1)

Evaluates two or more possibilities from a collection of comparison statements
The condition allows for two or more possibilities, known as a chained conditional

if (variable > value) {
  ...
} else if (variable < value) {
  ...
} else {
  ...
}

The next conditional statement we shall look at is statements with the else if keyword. It provides an alternative conditional statement to that of the if. These are often referred to as chained conditionals as you can have a number of else if' statements.

The general structure for these kinds of statements would have the original if statement, which will perform some sort of check. If this check fails, then the C++ compiler will move onto the alternative else if statement, and check whether this condition can be satisfied. If it can be satisfied and evaluates to true, then the code within the else if body will be executed. Otherwise, if the condition were to evaluate to false, then it will either move onto another else if condition check, or the else clause, and execute the code that resides within the body for either of those.

`else if` Statements (2)

Example: `else if` Statement i

Declare a variable ifExample1 to store the integer value 1
Declare a variable ifExample2 to store the integer value 3
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value [True] ifExample1 is 1 to the screen
Stop the comparison checks!

#include <iostream>
int ifExample1 = 1;
int ifExample2 = 3;
int main() {
  if (ifExample1 == 1) {
    std::cout << "[True] ifExample1 is 1" << std::endl;
  } else if (ifExample2 == 2) {
    std::cout << "[True] ifExample2 is 2" << std::endl;    
  } else {
    std::cout << "[False] ifExample1 is not 1, and ifExample2 is not 2" << std::endl;
  }
  return 0;
}

[True] ifExample1 is 1

Let’s have a look at an example. We have our variable ifExample1 which has been assigned the value one. Our conditional statement checks whether ifExample1 is the same as one and because these two values match, then our condition is met and the code situated inside the if statement will be executed. In this instance, the value [True] ifExample1 is 1 is printed to the terminal window.

However, if this condition had evaluated to False then we would be moved onto the next conditional check. If that conditional check had evaluated to False we would then be moved onto the final else clause. You may want to think of the else clause as being the ultimatum case, whereby if all checks failed beforehand, this would be the default response.

`else if` Statements (3)

Example: `else if` Statement ii

Declare a variable ifExample1 to store the integer value 3
Declare a variable ifExample2 to store the integer value 2
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value [True] ifExample1 is 1 to the screen
- otherwise, perform another conditional check: ifExample2 is equal to 2?
  - if True: print the value [True] ifExample2 is 2 to the screen
Stop the comparison checks!

#include <iostream>
int ifExample1 = 3;
int ifExample2 = 2;
int main() {
  if (ifExample1 == 1) {
    std::cout << "[True] ifExample1 is 1" << std::endl;
  } else if (ifExample2 == 2) {
    std::cout << "[True] ifExample2 is 2" << std::endl;    
  } else {
    std::cout << "[False] ifExample1 is not 1, and ifExample2 is not 2" << std::endl;
  }
  return 0;
}

[True] ifExample2 is 2

Let’s have a look at another example. We have our variable ifExample1 which has been assigned value three and ifExample2 which has been assigned value two. Our conditional statement checks whether ifExample1 is the same as one and because these do not match, then our script moves onto the next conditional check, that is performed by the else if case.

The else if conditional statement checks whether ifExample2 is the same as two and because these two values match, then our condition is met and the code situated inside the elif statement will be executed. In this instance, the value [True] ifExample2 is 2 is printed to the terminal window.

However, if this condition had evaluated to False then we would be moved onto the final else clause.

`else if` Statements (4)

Example: `else if` Statement iii

Declare a variable ifExample1 to store the integer value 1
Declare a variable ifExample2 to store the integer value 3
Perform a comparison check: ifExample1 equal to 1?
- if True: print the value [True] ifExample1 is 1 to the screen
- otherwise, perform another conditional check: ifExample2 is equal to 2?
  - if True: print the value [True] ifExample2 is 2 to the screen
  - otherwise, print [False], ifExample1 is not 1, and ifExample2 is not 2

#include <iostream>
int ifExample1 = 1;
int ifExample2 = 3;
int main() {
  if (ifExample1 == 1) {
    std::cout << "[True] ifExample1 is 1" << std::endl;
  } else if (ifExample2 == 2) {
    std::cout << "[True] ifExample2 is 2" << std::endl;    
  } else {
    std::cout << "[False] ifExample1 is not 1, and ifExample2 is not 2" << std::endl;
  }
  return 0;
}

[True] ifExample1 is 1

Let’s have a look at our final example. Here have our variable ifExample1 which has been assigned value three and ifExample2 which has also been assigned value three. Our conditional statement checks whether ifExample1 is the same as one and because these do not match, then our script moves onto the next conditional check, that is performed by the else if case.

The else if conditional statement checks whether ifExample2 is the same as two and because these do not match, then our script moves onto the final else clause. Because the else clause is seen as our ultimatum, there is no conditional check and the value [False], ifExample1 is not 1, and ifExample2 is not 2 is printed to the screen.

Nested `if` Statements

Nested `if` Statements (1)

if statements can be written inside each other
- this is known as nesting

if (variable == value) {
  if (variable1 == value1) {
    ...
  } else if (variable1 == value2) {
    ...
  } else {
    ...
  }
} else {
  if (variable2 == value1) {
    ...
  } else {
    ...
  }
}

The last type of conditional statements we shall be discussing, is the nested if statements. As the name may suggest, nested refers to another set of conditional statements being present inside another conditional statement. You can observe this by seeing an example structure of a nested if statement. This example is a little convoluted; however, it does provide a good example of how nested statements can be constructed.

On the screen, you can see we have our initial if statement, which is checking whether the value for a particular variable is equal to that of a given value. If this was to evaluate to True, then it moves inside to the body of the if statement.

In this case, another conditional check will be performed, and if that was evaluated to True then it will perform some kind of operation, as denoted by the three dots. However, if it was to evaluate to False then it will move inside the else clause, which is still inside our original if statement.

In the else clause, we can see that we have another if ... elif ... else statement. I am going to stop here, as it is going to get rather confusing, but you can understand the gist of where this is going. Over the next few slides we are going to look at some examples of a nested if statement.

Nested `if` Statements (2)

Example: Nested `if` Statement i

Declare a variable ifExample1 to store the integer value 1
Declare a variable ifExample2 to store the integer value 2
Perform a comparison check: ifExample1 equal to 1?
- if True: perform another comparison check: ifExample2 equal to 2?
  - if True: print [True] ifExample1 is 1 and ifExample2 is 2
Stop the comparison checks!

#include <iostream>
int ifExample1 = 1;
int ifExample2 = 2;
int main() {
  if (ifExample1 == 1) {
    if (ifExample2 == 2) {
      std::cout << "[True], ifExample1 is 1, and ifExample2 is 2" << std::endl;    
    } else if (ifExample2 == 4) {
      std::cout << "[True] ifExample1 is 1 and ifExample2 is 4" << std::endl;
    } else {
      std::cout << "[True] ifExample1 is 1 but, ifExample2 is not 2 or 4" << std::endl;
    }
  } else {
    std::cout << "[False] ifExample1 is not 1" << std::endl;
  }
  return 0;
}

[True], ifExample1 is 1, and ifExample2 is 2

On the screen we have oa nested if statement example, whereby we shall be performing a check upon two variables, ifExample1 and ifExample2. Each of these variables has been assigned an integer value, one and two, respectively.

The first conditional statement is checking whether ifExample1 is equal to one. In this instance, we can observe that ifExamplw1 is storing the value one, and as such this condition check will evaluate to True and we move inside the body of our if statement.

Inside the body of this if statement, we can see that we have another condition check, and this one is checking whether ifExample2 is equal to two. Here, we can see that our variable, ifExample2 is storing the value two and as such this condition will evaluate to True. In this case, the following string will be printed on the screen: “True, ifExample is 1 and ifExample2 is 2”.

There are no further checks that are required to be made.

Nested `if` Statements (3)

Example: Nested `if` Statement ii

Declare a variable ifExample1 to store the integer value 1
Declare a variable ifExample2 to store the integer value 4
Perform a comparison check: ifExample1 equal to 1?
- if True: perform another comparison check: ifExample2 equal to 2?
  - if True: print [True] ifExample1 is 1 and ifExample2 is 2
  - otherwise perform another comparison check: ifExample2 equal to 4?
    - if True: print [True] ifExample1 is 1 and ifExample2 is 4
Stop the comparison checks!

#include <iostream>
int ifExample1 = 1;
int ifExample2 = 4;
int main() {
  if (ifExample1 == 1) {
    if (ifExample2 == 2) {
      std::cout << "[True], ifExample1 is 1, and ifExample2 is 2" << std::endl;    
    } else if (ifExample2 == 4) {
      std::cout << "[True] ifExample1 is 1 and ifExample2 is 4" << std::endl;
    } else {
      std::cout << "[True] ifExample1 is 1 but, ifExample2 is not 2 or 4" << std::endl;
    }
  } else {
    std::cout << "[False] ifExample1 is not 1" << std::endl;
  }
  return 0;
}

[True] ifExample1 is 1 and ifExample2 is 4

The next example we shall be looking at, we are going to change the values of our variables, ifExample1 and ifExample2. Each of these variables has been assigned an integer value, one and four, respectively.

Inside the body of this if statement, we can see that we have another condition check, and this one is checking whether ifExample2 is equal to two. Here, we can see that our variable, ifExample2 is storing the value four and as such this condition will evaluate to False. Therefore, we move onto our next conditional check, and check whether the variable ifExample2 is equal to four. In this case, the following string will be printed on the screen: “True, ifExample is 1 and ifExample2 is 4”.

There are no further checks that are required to be made.

Nested `if` Statements (4)

Example: Nested `if` Statement iii

Declare a variable ifExample1 to store the integer value 2
Declare a variable ifExample2 to store the integer value 5
Perform a comparison check: ifExample1 equal to 2?
- if True: perform another comparison check: ifExample2 equal to 2?
- otherwise, print [False] ifExample1 is not 1
Stop the comparison checks!

#include <iostream>
int ifExample1 = 2;
int ifExample2 = 5;
int main() {
  if (ifExample1 == 1) {
    if (ifExample2 == 2) {
      std::cout << "[True], ifExample1 is 1, and ifExample2 is 2" << std::endl;    
    } else if (ifExample2 == 4) {
      std::cout << "[True] ifExample1 is 1 and ifExample2 is 4" << std::endl;
    } else {
      std::cout << "[True] ifExample1 is 1 but, ifExample2 is not 2 or 4" << std::endl;
    }
  } else {
    std::cout << "[False] ifExample1 is not 1" << std::endl;
  }
  return 0;
}

[False] ifExample1 is not 1

By now, I think you understand how these nested if statements are working. However, it would be rude to not finish of our example and not reach our final else clause. In this final example we shall be looking at, we are going to change the values of our variables, ifExample1 and ifExample2. Each of these variables has been assigned an integer value, two and five, respectively.

The first conditional statement is checking whether ifExample1 is equal to one. In this instance, we can observe that ifExamplw1 is storing value two, and as such this condition check will evaluate to False and we move immediately to our else clause and execute the code inside it. In this case, the string “[False] ifExample1 is not 1” will be printed to the screen.

There are no further checks that are required to be made.

Control Statements

Control Statements (1)

Typically, statements in code will be executed sequentially
There are some situations that require a block of code to be repeated
- i.e. summing numbers, capturing multiple user-input etc.
Control statements, otherwise known as loop statements, are required
Three types of loops in C++:
- while
- do ... while ...
- for

Before we begin discussing the structure of control statements, we shall first delve into why control statements are important for developers. As you will be aware, Python executes code in a line-by-line fashion, and as such,code is executed sequentially. This is also true for C++, to a point. However, there are often situations when a developer requires a block of code to be repeated, e.g. the summation on a collection of numbers, entering multiple data points or capturing multiple inputs from a user.

Control statements, otherwise known as loop statements, are required to repeat these blocks of code. C++ provides three useful loop structures: while, do while, and for.

`while` Loops

`while` Loops (1)

A loop that executes zero or more times before it is terminated
Used to evaluate upon a condition
- if the condition evaluates to 1 (true) the code inside the loop will be executed
- if the condition evaluates to 0 (false) the loop will terminate

while (variable < value) {
  ...
  variable += 1;
}

THe first loop structure we shall look at are while loop statements. These types of loops will execute zero or more times before it becomes terminated. On the screen you can see the typical structure for a while loop. However, they can also be constructed in slightly different way (more on this in a second).

The loop structure shown on the screen begins with the while keyword. This is an important keyword, as it is the one that denotes that this particular bit of code will be a loop. The while loop shown will check whether a particular variable is less than a given value, which has been encompassed by a set of round brackets.

The dots shown in the body of the while loop is symbolic of code that may be present if this was an actual piece of code. The line after is the most important part, variable += 1. If we do not call this piece of code at the end of a while loop, then it will not increment and as such we would not “loop”, so to speak. Therefore, we are required to manually increase the value of variable in order for a loop to continue.

Over the next few slides, we shall be looking at while loops in more detail.

`while` Loops (2)

Initiate a new variable: whileExample1 = 0
Provide a condition to evaluate on: whileExample1 <= 5 evaluates to 1 (true)
- execute the code inside the while loop:
  - prints the value of whileExample1
  - increments whileExample1 by 1
Loop is repeated until condition evaluates to 0 (false)

#include <iostream>
int whileExample1 = 0;
int main() {
  while (whileExample1 <= 5) {
    std::cout << "whileExample1 -> " << whileExample1 << std::endl;
    whileExample1 += 1;
  }
  return 0;
}

whileExample1 -> 0
whileExample1 -> 1
whileExample1 -> 2
whileExample1 -> 3
whileExample1 -> 4
whileExample1 -> 5

On the screen you can see an example of a while loop, whereby we are continuously checking whether the variable whileExample1 is less than ten. If it is less than or equal to five, then we shall print the value of whileExample1 to the screen. After the value has been printed, we then will need to increment our variable by one manually. Now that we understand the nature of what is happening with this loop, we can look at this in a little more detail.

On our first iteration, the variable whileExample1 is zero. The first thing to happen is that our while loop will check whether whileExample1 is less than ten, and because the variable value is zero, our conditional check will evaluate to True. This means that we shall move into the body of the loop and print the value of whileExample1 to the screen and then manually increment the value of whileExample1 to one.

This then proceeds us to moving onto our second iteration, and repeat the same process as earlier. We check whether whileExample1 is less than ten and because this conditional check evaluates to True we can print the value of our variable to the screen and manually increment whileExample1 to two.

Now let’s move on and look at a third iteration… or not. Hopefully by now you should be aware of how this while loop works. Therefore, I am going to skip a few steps and get to the point where whileExample1 is storing value nine.

As usual, the first thing we need to do is check whether whileExample1 is less than ten. As we have skipped a few steps, our variable now holds value nine, and in this instance it satisfies our check and evaluates to True. We then print the value of whileExample1 to the screen and proceed with manually increasing our variable value to six.

With our variable now storing value six, we go back and perform our conditional check once more. However, this time, we can see that whileExample1 is not less than six and therefore the condition evaluates to False and we are unable to proceed into the body of our while loop. It is at this point that our loop has terminated.

`while` Loops (3)

Breaking a `while` Loop

break statements can be used to stop the loop if a condition is evaluated to true
Initiate a new variable: whileExample1 = 0
Provide a condition to evaluate on: whileExample1 <= 5 evaluates to 1 (true)
- execute the code inside the while loop:
  - prints the value of whileExample1
  - increments whileExample1 by 1
Loop is repeated until the conditional statement in the loop evaluates to 1 (true)
- in this instance, when whileExample1 is 2

#include <iostream>
int whileExample1 = 0;
int main() {
  while (whileExample1 <= 5) {
    std::cout << "whileExample1 -> " << whileExample1 << std::endl;
    if (whileExample1 == 2) {
      break;
    }
    whileExample1 += 1;
  }
  return 0;
}

whileExample1 -> 0
whileExample1 -> 1
whileExample1 -> 2

while loops have the option of being terminated early if it meets a specific threshold, other than the one that was originally outlined in the construction of it. This can be achieved using a conditional statement, followed by the usage of the break keyword.

The break keyword can be used to terminate a loop if a certain condition has been evaluated to True. On the screen you can see our example from earlier, but with a slight modification. Inside the while loop is a conditional check to determine whether whileExample1 is equal to two. If this condition was to evaluate to True, then the break keyword will be met and the loop will be terminated early.

Let’s look at an example and see what happens when we iterate through our loop shown on the screen. We are going to skip a few iterations and start at our loop where our variable whileExample1 is storing value one. With our variable storing value one the loop will perform the check on whether it is less than or equal to five, and in this instance the conditional check evaluates to True, and we can move inside the loop and execute the code.

Inside the while loop we print the value of whileExample1 to the screen, and perform an additional check to see whether it meets our threshold of two. In this instance, as whileExample1 is one, it does not meet our threshold and as such carries on processing the code that is inside the loop. In this case, it will increment the value of whileExample1 by one.

We then proceed onto our next iteration of the loop, where our variable whileExample1 now stores value two. Our while loop will perform a check on whether this variable is less than or equal to five, and as this check evaluates to True we can proceed with moving inside the loop to execute the code. Inside the loop, we print the value of our variable to the screen and proceed with performing a conditional check on whether it has met our threshold.

Here, we are checking whether whileExample1 is equal to two, and in this case the threshold check evaluates to True and we move inside the body of the if statement. Inside the body is the keyword break and as we know, this can be used to terminate the loop. Therefore, at this point we break out of the loop and continue executing the code below it.

You can see from the output on the screen that the print statement was only executed a total number of three times, printing our values zero to two.

`while` Loops (4)

Skipping an Iteration

continue statements can stop the current iteration and continue onto the next
Initiate a new variable: whileExample1 = 0
Provide a condition to evaluate on: whileExample1 <= 5 evaluates to 1 (true)
- execute the code inside the while loop:
  - prints the value of whileExample1
  - increments whileExample by 1
Loop is repeated until the conditional statement in the loop evaluates to 1 (true)
- in this instance, when whileExample1 is 2

#include <iostream>
int whileExample1 = 0;
int main() {
  while (whileExample1 <= 5) {
    whileExample1 += 1;  
    if (whileExample1 == 2) {
      std::cout << "SKIPPED" << std::endl;
      continue;
    }
    std::cout << "whileExample1 -> " << whileExample1 << std::endl;
  }
  return 0;
}

whileExample1 -> 1
SKIPPED
whileExample1 -> 3
whileExample1 -> 4
whileExample1 -> 5
whileExample1 -> 6

while loops can skip iterations, and this can be achieved by using the continue keyword. The logic for this kind of loop is very similar to the way you would use a break statement. Instead, replacing the break with a continue, and instead of terminating the loop it will skip onto the next value.

On the screen we have an example of a while loop using the continue keyword. There are some slight changes to this example compared to the previous examples. With this example you can see that the manual increment of our variable whileExample1 has been moved to the first line inside the loop body. Below this, we have the condition to check whether our threshold has been met. In this instance, it is the same as previously, with the threshold being set to two. If this threshold is met, then we shall continue with our loop, by proceeding to the next iteration and skipping the print statement that is below the threshold check. Otherwise, if our variable does not meet the threshold, then we shall print the value of our variable to the screen.

Now that you understand the structure of the while loop, let’s walk through our example, iteration by iteration. To save some time, we shall skip some iterations and start at the moment our variable has been assigned value two. With the variable holding value one, the while loop will check whether whileExample1 is less than five and in this case the condition will evaluate to True. This means that we can move inside the body of our loop and increment the value of whileExample1 by one and proceed with our threshold check.

Our threshold condition checks whether whileExample1 is equal to two, and this instance it will evaluate to True as we incremented our variable before our threshold check. We therefore move inside the body of the if statement and execute the continue keyword. Upon execution, we are automatically taken outside the body of the loop, and return to the beginning of our while loop and begin a new iteration.

With our new iteration, we perform a check with our while loop on whether whileExample1 is less than five. As the value of our variable is now three, this will evaluate to True and we can move inside the body of our loop. Inside the loop, we shall increment the value of our variable by one, making it four. We perform a threshold check, and as four is not equal to two, we skip the if statement and print the value to the screen.

This is where I shall stop walking through our example, and explain what has happened. You can see that when we execute this script, the following values have been printed to the screen: 1, 3, 4, 5, and 6. But what happened to value two? Well, this value was never printed to the screen as it was our threshold check. Meaning that when we reached two, it skipped the print statement and moved onto the next iteration, three.

`while` Loops (5)

Infinite `while` Loops

Infinite loops can be constructed by using a true value after the while keyword
- in this case with C++ - 1
Will continue incrementing whileExample1 until it reaches a certain value
- in this instance whileExample1 must be equal to 5
If there is no condition to check in the loop, it will continue incrementing

#include <iostream>
int whileExample1 = 0;
int main() {
  while(1) {
    std::cout << "whileExample1 -> " << whileExample1 << std::endl;
    whileExample1 += 1;  
    if (whileExample1 == 5) {
      break;
    }
  }
  return 0;
}

whileExample1 -> 0
whileExample1 -> 1
whileExample1 -> 2
whileExample1 -> 3
whileExample1 -> 4

We shall discuss this a little more later on, but I wanted to explain this now as there is a different method of constructing your while loops. Instead of having a while loop evaluate for a certain condition, you can have loop for an infinite number of iterations. To do this, you can use the while keyword with the integer value one following it, which is the compiler representation of boolean value true.

With this statement, we will have a loop that can run for an infinite number of iterations. To end this sort of loop, you need some sort of conditional check in the body of the loop to stop it from running. In this instance it has been decided to end the loop once whileExample1 reaches the value five.

You may be thinking to yourself, why would I want a loop to iterate an infinite number of times? Well, in some instances, you may want this to happen, such as a keylogger, and it will only stop if a certain key combination is pushed. Alternatively, if you are doing some computer vision work, you may want an infinite loop to continue reading all the frames from a web-camera in order for you to perform some operation on them. There are many possibilities as to why you may want an infinite loop, and just like Python, in C++ we have a method of achieving this.

`do ... while` Loops

`do ... while` Loops (1)

A variant of the while loop structure
One important difference:
- the execution of a do ... while is performed before the conditional check is evaluated

do {
  ...
}
while (condition);

`do ... while` Loops (2)

Initiate a new variable: doWhileExample1 = 0
Execute the code inside the do statement:
- prints the value of doWhileExample1
- increments doWhileExample1 by 1
doWhileExample1 <= 5 evaluates to 1 (true)
Loop is repeated until condition evaluates to 0 (false)

#include <iostream>
int doWhileExample1 = 0;
int main() {
  do {
    std::cout << "doWhileExample1 -> " << doWhileExample1 << std::endl;
    doWhileExample1 += 1;
  }
  while (doWhileExample1 <= 5);  
  return 0;
}

doWhileExample1 -> 0
doWhileExample1 -> 1
doWhileExample1 -> 2
doWhileExample1 -> 3
doWhileExample1 -> 4
doWhileExample1 -> 5

`for` Loops

`for` Loops (1)

A loop that is designed to increment a counter over a given range of values
They are best suited for problems that need to iterate a specific number of times
- i.e. looping through a directory or set of files
Considered to be a pre-test loop
- they check their condition before execution
for loops are useful because…
- they know the number of times a loop should be iterated
- they use a counter
- require a false condition to terminate the loop

for (initialisation; condition; update) {
  ...
}

initialisation: initialises the counter-variable
- i.e. int i = 0;
condition: if 1 (true) the body of the loop is executed, if 0 (false) the loop is terminated
update: increments the counter-variable and checks the condition again
- i.e. i++

The next type of control statement is the for loop, and this has been previously introduced to you in the first year programming module. However, as you would have seen from the previous slides, the structure of control statements is different, with additional curly braces and semicolons.

for loops are designed to increment a counter for a given range of values. In this instance, it shall automatically increment our value by one.

These sorts of loops are best suited for problems that need to iterate for a specific number of times. For example, when you want to iterate through a directory of files, and they are considered to be a pre-test loop, meaning that they check their condition before anything is executed.

You may be thinking to yourself, “why would I want to use a for loop over a while loop”. Well, the answer to that is… A for loop knows the number of times it is required loop and will automatically terminate itself. This is achieved by using a counter that is automatically incremented, and once a condition has been evaluated to false the loop will be terminated.

The structure of a for loop in C++ is different to that in Python. On the screen, you will see an example of how you would create your loop. You will see that just like Python, we begin with the for keyword, followed by a set of round brackets. Inside these round brackets, things are a little different. Here we need to declare three things, the initialisation, condition and an update.

The initialisation is concerned with initialising our counter-variable, and this will only be executed once. This would be an integer data type, and in most cases would start at zero. In C++, this would normally look like a normal variable declaration, i.e. int i = 0.

Following this is the condition statement, is our evaluator for our for loop. If true, or one, then the body of our loop will be executed. Otherwise, if it evaluates to false or zero, then our loop will be terminated.

The last statement is updated, and this updates our counter that was initialised earlier. This will then proceed and check the condition statement once again. In most cases, this will be incrementing our counter by one, i.e. i++. In some cases though, it could be used to decrement our counter, i.e. i--.

`for` Loops (2)

Example: Iterating Forwards

Initialise our counter, int i = 0;
Provide a conditional check:
- i.e. i < 5 - checks whether the integer is less than 5
If the condition is 1 (true) then execute the code within the for body
- in this instance, it will print the value of i
Increment the counter by one, i++
Loop until the conditional check evaluates to 0 (false)

#include <iostream>
int main() {
  for (int i = 0; i < 5; i++) {
    std::cout << "i -> " << i << std::endl;
  }  
}

i -> 0
i -> 1
i -> 2
i -> 3
i -> 4

On the screen, you can see an example of how a for loop can be used to iterate forwards. This is a relatively simple example to ensure that you understand how the syntax and structure of the for loop works.

As you can see, we first begin by declaring our for keyword. This tells the C++ compiler that we are going to be creating a loop. Inside the round brackets we need to initialise our counter-variable. You should recall from the first year programming module that when we create counter-based for loops, our variables are often named i, j or k, depending upon the level of loop being used, more on nested loops soon. In this example, I have decided to create an integer variable named i.

Once we have created our counter-variable, we now need to create a conditional check. This is the statement that will be evaluated whilst our loop is iterating. It is important to note that between our counter-initialisation and the statement, there is a semicolon, and this is used to split out declarations. After our statement has been declared, we then provide a method of updating our counter-variable. As I am concerned with iterating forwards, I will be incremented our counter by plus one each time. Instead of doing i = i + 1, or i += 1 in C++, we can use i++ to increment our counter. Inside the body of our for loop, we have a print statement, which will output the value of i to the screen.

You will see in the blue box the outcome of our loop. Each time our loop statement has evaluated to true, it has printed the value of i to the screen, and then incremented the counter by one. This, in turn, has led to the print statement being executed again, and so on, with values zero to four being printed to the screen.

`for` Loops (3)

Example: Iterating Backwards

Initialise our counter, int i = 5;
Provide a conditional check:
- i.e. i > 0 - checks whether the integer is less than 5
If the condition is 1 (true) then execute the code within the for body
- in this instance, it will print the value of i
Increment the counter by one, i--
Loop until the conditional check evaluates to 0 (false)

#include <iostream>
int main() {
  for (int i = 5; i > 0; i--) {
    std::cout << "i -> " << i << std::endl;
  }  
}

i -> 5
i -> 4
i -> 3
i -> 2
i -> 1

The previous example looked at iterating forwards using a for loop. You should know by now that we can do the inverse of something in programming. Therefore, we have the ability to also iterate backwards. In this example, we are concerned with counting down from five to one.

On the screen, you will see the structure of our for loop and how this can be achieved. It is quite similar to our previous example. However, the main difference is in the construction of our for. For example, you can see that the initialisation of counter-variable now begins at five, instead of zero. The statement itself has also been flipped, checking whether i is greater than zero. Finally, the update statement has also been changed, this time it decrements our counter-variable by using i-- which is similar to saying i = i - 1.

The output on the screen shows that our loop initially begins at five, and for each turn it decreases by one. This is continued until our condition of whether i > 0 evaluates to false. It is at this point, when i become zero that our loop will stop executing. This is the reason as to why zero is not printed to the screen, as technically 0 is not greater than 0, it is the same.

`for` Loops (4)

Range-Based Loops

Range-based loops can be used to work on arrays and vectors
The syntax of a range-based loop:

for (variable : [array or vector]) {
  ...
}

For each element in the array or vector, the loop is executed
- the element will be assigned to the variable

Range-based loops are a little different in comparison to Python. In Python, you will be familiar with the range function which enables us to loop through a range of numbers. However, in C++ the term range is meant in a different manner.

Instead, we are more concerned about looping through an array or vector (or sometimes a dictionary, more on this soon). The syntax for these kinds of loops is a little different. On the screen, you will see an example of how we would create our range-based loop. Inside the set of round brackets, we declare a variable using a data type, which is followed by a colon, and the variable name for an array or vector. We then have the normal ... which symbolises the body of our for loop and will contain code that is executed when extracting information from our array or vector.

Essentially, what this for loop is doing is extracting each element, one-by-one, from the array or vector and assigning it to a temporary variable. We can then use this temporary variable to perform some sort of operation upon it. This will make more sense on the next slide, with our example.

`for` Loops (5)

Example: Range-Based Loops i

Create the variable to store an element from the array
- i.e. int i
Each element inside the array will be assigned to i
- it will then be printed to the terminal window
Loop will terminate when no more elements exist in the array

#include <iostream>
int intArrayExample1[5] = {0, 1, 2, 3, 4};
int main() {
  for (int i : intArrayExample1) {
    std::cout << "i -> " << i << std::endl;
  }  
}

i -> 0
i -> 1
i -> 2
i -> 3
i -> 4

Let’s have a look at an example of how this would work with an array. On the screen, you can see that I have created an array called, intArrayExample1. The array has been initialized, and stores the values zero to four. However, we want to use a range-based loop in order to access each element individually and perform some form of operation on it.

Therefore, to do this, I need to create my loop. As usual, this will begin with declaring the for keyword, followed by a set of round brackets. Inside the brackets, I need to declare a temporary variable to store our element from the array. As we know that my array consists of integers, the data type of my temporary variable needs to be int, and I can then choose an appropriate variable name. In this case, I have chosen to use i as my variable name.

Once we have created our temporary variable, we now place a colon and precede this with the name of our array. In this case, the name of my array is intArrayExample1. We can now move inside the body of our loop and begin to write some code on what we want to do with each element. As normal with my examples, I want to be able to print the value to the screen. Therefore, the normal method of printing to the screen has been applied.

As you can see from the output on the screen, when we begin iterating through our array, each element has been printed individually to the screen. This is a similar process to what you could achieve in Python by using the in keyword. However, in this instance we have substituted the in with a colon.

`for` Loops (6)

Example: Range-Based Loops ii

Create the variable to store an element from the array
- i.e. auto item
Each element inside the map will be assigned to item
- the key and value of each element can be accessed by:
  - first: returns the key
  - second: returns the value
- they then be printed to the terminal window
Loop will terminate when no more elements exist in the map

#include <iostream>
#include <map>
std::map<int, std::string> mapExample1 = {{0, "Ian Cornelius"}, {1, "Terry Richards"}, {2, "Daniel Goldsmith"}};
int main() {
    for (auto &item : mapExample1) {
        std::cout << "item.first -> " << item.first << std::endl;
        std::cout << "item.second -> " << item.second << std::endl;    
    }
}

item.first -> 0
item.second -> Ian Cornelius
item.first -> 1
item.second -> Terry Richards
item.first -> 2
item.second -> Daniel Goldsmith

Range-based loops are particularly useful when it comes to extracting the data from a map. On the screen, you will see a variable called mapExample1. This should be familiar to you from the previous lecture on advanced data types in C++. Here, we have a map that stores the name of a lecturer on your course. It has been designed in a way that an integer value is used as they key, and the lecturer is stored as a string.

This can make it a little difficult when trying to extract data using a range-based loop. However, C++ provided a keyword known as auto. This allows the compiler to automatically detect and assign the data type to the variable that is being used, in this case our variable is called item.

When we try to extract an item, it is extracted as a pair in C++, meaning that each item is extracted at once and can be accessed individually using the first and second variable. Let’s have a look at our example on the screen and explain how this works.

You will see on the screen that I have created a for loop using the auto keyword, followed by the auto keyword and the name of my variable I want to extract to. You can ignore the ampersand for now, this will be discussed in another week; but it is important to include it here. After I have declared my variable to temporarily store an extracted element, I need to then provide the name of the map that I am extracting my data from, in this case mapExample1.

When this loop begins, it will extract the first key:value pair from our map and store it into our variable called item. In order to access each part of our pair, we need to call the first and second variables from item. This is done in the method of item.first and item.second. What this will do is access the key and value that is stored in our map, respectively. Therefore, item.first would extract our key, and item.second would extract our value.

You can see from the output on the screen the outcome of this loop. For the first iteration, we have extracted our first lecturer. Therefore, when we called item.first it retrieved the keys’ value, which is zero, and item.second retrieved the value being stored by that key, which in this case was Ian Cornelius.

The auto keyword can be quite dangerous in C++, and as such I would only suggest you use this when using a range-based for loop and extracting data from an array, vector or map. The reason it is considered to be dangerous is that you are not taking control of the variable data type. This could lead to bugs within your code, and they would not necessarily be made clear when trying to debug your work.

`for` Loops (7)

Infinite Loops

Infinite loops can also be created using a for
A condition is required that will always evaluate to 1 (otherwise known as true)

for(int i = 1; i > 0; i++) {
  ...
}

In this instance, the integer i will always be greater than 0
Some method of terminating will be required
- i.e. checking whether i is a particular value

The last thing I want to discuss about for loops, are infinite loops. You would have been introduced to this concept in your first year programming module, and the same methodology can be carried over to C++.

In this case, to create an infinite loop, we need to have a condition that will always evaluate to true or 1 in the case of C++. To do this, we can have an expression such as i > 0 and increment i by one each time. This will then ensure that our loop will continue looping indefinitely. However, you should always ensure that there is a method to break out of an infinite loop by using a conditional statement and the break keyword. This could be checking whether a loop gets to a certain value, and then using the break keyword.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk

Conditional and Control Statements in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Conditional Statements

Conditional Statements (1)

if Statements

if Statements (1)

if Statements (2)

Example: if Statement i

if Statements (3)

Example: if Statement ii

if else Statements

if else Statements (1)

if else Statements (2)

Example: if else Statement i

if else Statements (3)

Example: if else Statement ii

else if Statements

else if Statements (1)

else if Statements (2)

Example: else if Statement i

else if Statements (3)

Example: else if Statement ii

else if Statements (4)

Example: else if Statement iii

Nested if Statements

Nested if Statements (1)

Nested if Statements (2)

Example: Nested if Statement i

Nested if Statements (3)

Example: Nested if Statement ii

Nested if Statements (4)

Example: Nested if Statement iii

Control Statements

Control Statements (1)

while Loops

while Loops (1)

while Loops (2)

while Loops (3)

Breaking a while Loop

while Loops (4)

Skipping an Iteration

while Loops (5)

Infinite while Loops

do ... while Loops

do ... while Loops (1)

do ... while Loops (2)

for Loops

for Loops (1)

for Loops (2)

Example: Iterating Forwards

for Loops (3)

Example: Iterating Backwards

for Loops (4)

Range-Based Loops

for Loops (5)

Example: Range-Based Loops i

for Loops (6)

Example: Range-Based Loops ii

for Loops (7)

Infinite Loops

Goodbye

Goodbye (1)

Questions and Support

`if` Statements

`if` Statements (1)

`if` Statements (2)

Example: `if` Statement i

`if` Statements (3)

Example: `if` Statement ii

`if else` Statements

`if else` Statements (1)

`if else` Statements (2)

Example: `if else` Statement i

`if else` Statements (3)

Example: `if else` Statement ii

`else if` Statements

`else if` Statements (1)

`else if` Statements (2)

Example: `else if` Statement i

`else if` Statements (3)

Example: `else if` Statement ii

`else if` Statements (4)

Example: `else if` Statement iii

Nested `if` Statements

Nested `if` Statements (1)

Nested `if` Statements (2)

Example: Nested `if` Statement i

Nested `if` Statements (3)

Example: Nested `if` Statement ii

Nested `if` Statements (4)

Example: Nested `if` Statement iii

`while` Loops

`while` Loops (1)

`while` Loops (2)

`while` Loops (3)

Breaking a `while` Loop

`while` Loops (4)

`while` Loops (5)

Infinite `while` Loops

`do ... while` Loops

`do ... while` Loops (1)

`do ... while` Loops (2)

`for` Loops

`for` Loops (1)

`for` Loops (2)

`for` Loops (3)

`for` Loops (4)

`for` Loops (5)

`for` Loops (6)

`for` Loops (7)