In previous episodes we have

discussed the notion of control structures.

They are special instructions,

making it possible to repeat

processing or to execute processing

according to a number of conditions.

Today, we will expand on this idea with another way

to repeat processing : the conditional loops.

If, in a program, we wish

to repeat a number of processing and that the number

of repetitions is known à priori, that is,

before entering the loop, it is possible

to use a "for loop".

However, there are situations where we wish to repeat processing

as long as a given condition

is true but we do not know how many times

it will be necessary to repeat the processing until

the condition becomes false. In such

a case we have to use other types of

repetition instructions :

The conditional loops. Their execution

depends on the fulfillment of a condition.

In C++ they appear as loops "do while" or "while".

For illustrations purposes, let us reuse our example

tasked with the computation of some grades' average.

A priori, we do not know

how many grades will be entered to calculate their average. We begin by

by asking it from the user. The number of

grades will thus be entered via keyboard interaction.

Then, if this number is positive, we will

use an iteration "for" and input all the grades.

At every iteration, a grade will be typed on the keyboard

and added to the sum of all grades.

Once all the grades have been entered, we will obviously

exit the iteration and continue

with the execution of the rest of the program

At this point, we will calculate the average and print it.

We can surmise that is not

very natural to let the user input a number of grades

equal to 0. Thus, we wonder

how to compel the user into

typing a number of grades

strictly greater than 0.

Concretely, we wish to repeat these instructions until

the user inputs a number of

grades strictly positive.

We do not know how many times

we will have to repeat these instructions, for we cannot

forsee a priori when the user will indeed

input a number strictly positive.

Thus, we will have tu use a special control structure.

What we are looking for, here, is the so-called

"do while" loop. The "do while" loop is written this way :

the keyword "do" followed by a pair

of braces and the keyword

"while" which means

to repeat as long as

this condition is true.

Concretely, we will repeat

these instruction inside

the body, that is

the instructions in the braces

as long as the condition is true.

Let us now examine step by step the execution flow of

our little example with the "do while" loop.

We presuppose that a variable "nombre_de_notes" has been previously declared

and is ready to contain the number of grades entered by the user.

Once we reach this instruction, nothing prevents us from

entering the loop's body.

At this point, we wil ask the user to input

the number of grades.

The number of grades is entered via keyboard interation.

Now this line will be executed, evaluating the

loop continuation condition.

Let us suppose that the user types,

as the number of grades, the value 0.

In this case, the evaluation of the condition will return

"true" which means that the number of grades doesn't

fulfill our criteria.

Since the condition is true, we will enter a new cycle.

Once again, we will thus execute the loop's body.

This time, let us suppose that

the user inputs, as number of grades,

the value -1.

During the evaluation of the continuation condition, this condition

will once again return true, for, of course, -1 is less or equal to 0.

At this point, we will

once again, enter a new cycle.

We begin our third iteration and, again,

we will ask the user to input the number of grades

and read it via keyboard interaction. Let us suppose, that this time,

the crestfallen user ends up understanding what we're expecting

and inputs number of grades strictly positive, for example, 6.

At this time, during the evaluation of the loop continuation

condition, the evaluation will return false since 6 is

strictly greater than 0. Thus, we exit the "do while" loop

and resume the execution right

after the semicolon concluding the "do while" instruction.

Now let us formally examine the syntax of a

"do while" instruction in C++.

The keywords "do while" frame the so-called

"do while body", which rests in braces.

Following the "while" is the

loop continuation condition. The semantic is as follows:

the processing within the body are repeated as long as the condition is "true".

Once again : we repeat the processing as long as the condition is "true".

Not unlike the instruction of a conditional branching,

the "do while" loop continuation

condition can be relatively complex, resorting

to logical operators.

For example, we can formulate such a condition :

let's repeat the processing as long as x is equal to y plus z and that

z is greater than 10 or t is less than 25.

Thus we can imagine pretty

sophisticated continuation conditions, especially resorting to

logical operators.

It is also worth noting that the parentheses around

the condition are absolutely mandatory in C++.

Just as it is with the"if", the condition

will be written in a pair of parentheses.

An important observation regarding the "do while" loop is

that its body will systematically be executed at least once.

Indeed, if we recall our

step by step example of a "do while" loop,

we see that at this point,

nothing prevents us from entering the body,

thus we will execute the block at least once.

However, this block will only be executed once if, after the

first iteration, the evaluation of the condition

returns "false".

In this case, we will simply resume the execution after

the loop.

But in the meantime, the block of instructions will have been executed once.

This is very important and stands among the "do while" loop's specificities.

Another observation : if the condition doesn't ever

become false, then the processing will be repeated indefinitely.

Consequently, one must be careful in the condition's formulation in order

to prevent an infinite loop. Indeed, infinite loops are generally

not the expected result,

at least not for beginners.

Those were the

core ideas regarding the "do while" loop.

Before we can put behind us

the topic of the "do while" syntax, please heed this last warning :

this semicolon here, at the end of the "do while" instruction,

which is rather easy to forget.

Now, there are situations where we wish to test the loop's condition

prior to the execution of the body.

In such as case, we will resort to another variant of

conditional loops : the "while" instruction.

Its syntax is as follows :

the keyword "while" immediately followed

by the condition, in parentheses.

Then comes the loop's body in braces.

The "while" loop is rather similar to the

"do while" loop : we will repeat the processing as long as

the condition returns true. The main difference is that, in the "while" loop,

the condition is tested before we enter the loop.

Thus, if the condition is

false from the get-go, we will immediately jump

to the next instruction after the "while", meaning that the block

will not be executed a single time. As we've seen before, it is not

the case with the "do while" loop

where the block will always be executed at least once.

Here are two basic examples, illustrating the

fundamental difference between "while" and "do while".

We have here two very similar loops,

with identical continuation conditions.

In both cases, the continuation condition relies on

a variable i, intialized to 100.

Let us start by examining

what happens during the execution of the "do while" loop.

When we reach the execution of the "do while",

nothing prevents us from entering the loop's body.

At this point, we will print

the message "bonjour".

Now we reach the point of the "do while" loop

where the continuation condition is evaluated.

Since i contains 100, the condition will of course return "false".

Thus we exit the loop and continue

the execution with the possible

instructions after the "do while".

In the meantime, the message "bonjour" has been displayed on the terminal.

Now on to the "while" loop. Upon this

line's execution, we will right away

test the condition which will, as before,

since both conditions are identical,

be evaluated as false. This means that we won't

ever enter the loop's body

and instead continue the execution

right after the "while". Thus, the loop has not printed anything.

Here, we found ourselves in a situation where two

very similar loops : one "do while" and one "while"

do not lead to the same result.

This is due to the time where the continuation condition is evaluated.

Among the classic mistakes among beginners using

the "while" and "do while" loops is one

possibly leading to very

puzzling results. This mistake relates

to our famous semicolon.

This semicolon marks the end of the "do while"

instruction and is placed right after the condition.

Now, if we were to add a semicolon after the

"while" condition, our program would behave strangely and, most importantly, incorrectly.

Let us see what would happen

if we added this semicolon.

This instruction would be interpreted

as if it were a "while" loop

with, as body, an empty instruction. Therefore, there is nothing

within the loop impacting i.

So, if i contained something

less than 10, for example 1, this loop would cycle indefinitely

since there is no way to make i reach a value

greater than 10, which would render the condition false.

As a matter of fact,

this ++i, which we probably wished

to be inside the body,

will never be reached if i started containing less than 10.

Indeed, this plus plus i instruction

will be considered as being outside the "while" loop.

Now you know three ways to repeat instructions

in a program : the "for loop"

which we have discussed

in a previous episode and what we have just seen,

namely the conditional loops which can take two forms,

either "while" or "do while".

Now, we will discuss

how to choose which form to use.

The choice depends on rather simple criteria.

If the number of repetitions is known a priori,

we will want to choose the "for" type iteration.

Imagine for example that you wish to calculate

the average of all students attending

this course. We know a priori how many students follow

this course. Thus, in order to calculate the sum of the grades

and the average, we will gladly

use a "for loop" since the number of iterations is known a priori.

However, if the number of iterations is not known

a priori, we will pick a conditional loop,

either "while" or "do while". Now how do we choose

between "while" and "do while" ?

Simply, we will ask

ourselves if we need to execute

at least once the loop's body.

If we want the body to be executed at least once,

which is the case, if we're interracting with the user,

for example, if we ask a value from the user and demand this value to be

between two values, we need the user to input the value

at least once before we can test if it fulfills the condition.

In this situation, we will rather resort to a

"do while" loop.

Otheriwse, we will naturally use a

"while" loop, that is,

a loop where the condition evaluation will

occur before entering the loop's body.

Now, let us enrich our little example from before.

It is a typical situation where a "do while" loop

is required since we need the user to input

the number of grades at least once before we can

test if this number is within the desired interval.

Thus we resorted to a "do while" loop. Now we

wish to upgrade this program a little so that

the user will be informed upon entering, for example,

a negative number, of the program's expectations.

So we wish to complete

the here program so that a

relevant message will be displayed when the user

enters a negative or null grade.

How should we proceed ?

Obviously, this message will appear every time the number

does not fulfill the desired condition.

Thus, it will probably be placed

within the loop's body : we will repeat this instruction

every time the user

inputs something incorrect.

We could imagine such a solution :

enriching the loop's body

with one more test. After having read the

entered value, we will test if the typed number

is less or equal to 0.

In this case, we will display a message to warn the user.

Please note, that this is indeed part of the loop's body

since we wish to repeat this process every time

an unsatisfactory number is entered.

As you can see in this example,

the condition testing if the number of grades

is less or equal to 0 appears now twice :

Once in the "if" and another

as the loop continuation condition.

It would have been smart to store the result of this evaluation

in a variable so that we do not need to evaluate it again.

For example, we can introduce a

boolean variable "saisie_invalide" initialized to "false". (TN: saisie_invalide means invalid_entry )

We will update this variable here, in the loop's body at every iteration,

storing the result of the condition evaluation, that is

"number of grades less or equal to 0". Thus, "saisie_invalide" will contain either "true" or "false"

This will allow us to write the condition

in a unified way, replacing this by

"if (saisie_invalide)" and we'll

resume the processing as before.

We will repeat the processing "while" the the variable "saisie_invalide" contains true.

This here is good practice.

In a program, we always wish to avoid

situations where we express the same thing

multiple times in independant ways, in several places.

It is like the copy-paste.

So, let us return to our little example

regarding the input of grades by a user.

Let us examine different ways to formulate the condition

in order to tend to different needs.

Until now, we compelled the user to type

a number of grades greater than 0.

Let us imagine,

that we wish to restrict the number of grades to 10.

The question we are asking is:

how do we formulate the condition with this new goal in mind ?

In order to formulate the continuation condition,

let us start by expressing it in plain words.

Now, the number of entered

grades will be incorrect in two cases :

either this number will be

less or equal to 0, which contradicts

this expectation, or the user will input a number

greater than 10, which contradicts this.

That means we will loop as long as

we find ourselves in either one of these situations.

In both cases, the number of grades, is incorrect.

It now becomes obvious

that we will have to resort to

the logical connective "OR". Namely,

we repeat the processing as long as either situation

is encountered.

In C++, this will be translated

by such a code. We repeat the processing as long

as the entered number of grades is less or equal to 0

OR that the number of grades is greater than 10.

Let us move on to another example. We wish to write a short

program which purpose is to make the user guess a number.

To simplify, let us imagine

that the number to guess is always 5.

The idea is to code a "do while" loop

asking a number from the user and comparing it

with the secret number. We will exit

the loop only once the number has been guessed.

We're wondering how to

formulate the condition so that

we exit the loop once the user has guessed the correct number.

As before, we will start by formulating the condition in plain words.

We know that

the loop is to be repeated as long as

the user has not guessed the secret number.

What does it concretely mean ?

They have not guessed correctly as long as the typed

number is different from the secret number, which is 5.

How do we formulate this condition in C++ ?

Simply through this line : we repeat the process

as long as the entered number is different from the secret number.

We notice that

the formulation in C++ is not too far from

the formulation in plain words.

Let us now enrich this example where the user is tasked with guessing

a number. We wish to give the user only a limited number of trials.

The poor fellow will not be allowed to guess

indefinitely. Thus we will resort to a

trial counter, that is, a variable we

introduce here. This trial counter will be

incremented at every loop iteration.

Now, we wish that,

after three trials, the game will be over

unless the user has guessed correctly.

Now we're wondering

how to formulate this condition.

Once again, let us start by formulating this condition in plain words.

We will repeat the loop as long as the user has not guessed

the correct number and as long as the user still has trials left.

It is clear that both conditions

must be fulfilled together.

We will keep iterating only if both conditions are fulfilled.

Now, let us try to formulate

this somehow closer to C++.

The first condition is that the entered number

is different from the secret number. The second

condition is that the number of trials is less

than 3. Both these conditions must be verified together.

In C++,

this translates into this line of code.

The first condition is that entered number is different from the secret number,

which translates into what is written here. The second condition is that

the number of trials must be less than 3, which translates into

what is written.

We have here the logical connective "AND" which guarantees.

that both conditions must be fulfilled simultaneously.

Again, we see, that the C++ formulation

is not too different from the formulation in plain words.

The user can now exit the loop in two different ways.

He can exit the loop because he has guessed correctly, in which case,

this part of the condition becomes false

or because he has run out of trials.

Now,

let us suppose that we wish to let the user know

why, concretely, he exits the loop.

Since we wish to inform the user of the reason why he

exits the loop, we need to enrich the program.

Once we have exited the loop,

we will test for which condition we have exited.

Did we exit the loop because of the failure

of this condition, namely, because the user has guessed

correctly. Or did we exit the loop

due to the failure of this second condition,

namely, because we ran out of trials.

Thus, we will run the test here.

If the entered number is equal to

the secret number, it means we exited the loop

because of this condition's failure and we can

inform the user that he has guessed correctly.

Otherwise, it means that the user has burnt all his trials

and we can inform his that he has lost the game.

We can also print the secret numer to let him know

what we were expecting from him.

However, we must avoid logical fallacies in the test formulation.

Let us imagine that, trying to the see if the

correct number has been guessed, we test if

the limited number of trials has been reached. In this case, the situation

where the user has guessed

the correct number exactly on his third trial

will be interpeted as a failure

while it was actually a success.

Thus, one must remain careful regarding the logic

in test formulations when we aim to realize such processing.

The correct way here was

the one presented in the first solution, namely

formulating the condition not in relation to

the number of trials but in relation to wether or not

the correct number has been guessed. This way,

we avoid the aforementioned trap.

Boucles conditionnelles

Initiation à la programmation (en C++)

Meet the Instructors