Ce cours initie aux bases de la programmation en utilisant le langage C++ : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en C++)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Boucles conditionnelles
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
210 notes
À partir de la leçon
Structures de contrôle (2) : boucles et itérations
Cette semaine, nous terminons la présentation des « structures de contrôle » avec les boucles et les itérations qui permettent de faire répéter certaines parties d'un programme.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
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.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
