Transcript 4/1 - EPFL

Support MOOC
Support MOOC
Concepts
centraux
Concepts
centraux
Approfondissements
Approfondissements
Etude de cas
Etude de cas
Vidéos et transparents
Programmation I :
Cours de programmation (C++)
Structures de contrôle en C++ (2) :
Boucles et itérations
https://class.coursera.org/initprogcpp-001/lecture
+ Semaine 3
Jamila Sam
Laboratoire d’Intelligence Artificielle
Faculté I&C
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 1 / 21
Support MOOC
Concepts
centraux
Quiz
Programmation I – Cours 4 : Boucles et itérations – 2 / 21
Support MOOC
Concepts
centraux
Boucles et itérations
Boucles et
itérations
Approfondissements
Etude de cas
Approfondissements
Etude de cas
Les boucles permettent la mise en oeuvre répétitive d’un
traitement.
La répétition contrôlée par une condition de continuation.
https://class.coursera.org/initprogcpp-001/quiz
I
boucles conditionnelles a priori
while (condition) {
Instructions
}
I
boucles conditionnelles a posteriori
do {
Instructions
} while (conditions);
+ Semaine 3
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 3 / 21
Programmation I – Cours 4 : Boucles et itérations – 4 / 21
Support MOOC
Concepts
centraux
Boucles et itérations (2)
Support MOOC
Concepts
centraux
Boucles et
itérations
Boucles : Exemple
Boucles et
itérations
Approfondissements
Approfondissements
Etude de cas
Etude de cas
I
itérations générales («à la C»)
for (initialisation ; condition ; mise_a_jour) {
Instructions
}
I
itérations sur ensembles de valeurs (CppOx))
int i(5);
while (i > 1) {
cout << i << endl;
i = i / 2 ;
}
affichera
+ plus tard (tableaux)
for (declaration : ensemble)
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 6 / 21
Programmation I – Cours 4 : Boucles et itérations – 5 / 21
Support MOOC
Concepts
centraux
Approfondissement
Support MOOC
Concepts
centraux
Approfondissements
Approfondissements
Etude de cas
Etude de cas
Sauts : break et continue
C++ fournit deux instructions prédéfinies, break et continue,
permettant de contrôler de façon plus fine le déroulement d’une
boucle.
I
l’instruction break
I
l’instruction continue
I
Si l’instruction break est exécutée au sein du bloc intérieur
de la boucle, l’exécution de la boucle est interrompue
(quelque soit l’état de la condition de contrôlle);
I
Si l’instruction continue est exécutée au sein du bloc
intérieur de la boucle, l’exécution du bloc est interrompue et la
condition de continuation est évaluée pour déterminer si
l’exécution de la boucle doit être poursuivie.
Conseil : En toute rigueur on n’aurait pas besoin de ces
instructions, et tout bon programmeur évite de les utiliser.
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 7 / 21
Programmation I – Cours 4 : Boucles et itérations – 8 / 21
Support MOOC
Concepts
centraux
Instructions break et continue
Support MOOC
Concepts
centraux
Approfondissements
Approfondissements
Etude de cas
Etude de cas
while (condition) {
...
instructions de la boucle
...
break
...
continue
...
}
instructions en sortie de la boucle
...
Breaking (it too) bad
Pour la petite histoire, un bug lié à une mauvaise utilisation de
break; a conduit à l’effondrement du réseau téléphonique longue
distance d’AT&T, le 15 janvier 1990. Plus de 16’000 usagers
ont perdu l’usage de leur téléphone pendant près de 9 heures.
70’000’000 d’appels ont été perdus.
[P. Van der Linden, Expert C Programming, 1994.]
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 9 / 21
Support MOOC
Concepts
centraux
Instruction break : exemple
Approfondissements
Etude de cas
Programmation I – Cours 4 : Boucles et itérations – 10 / 21
Support MOOC
Concepts
centraux
Instruction continue : exemple
Approfondissements
Exemple d’utilisation de break :
une mauvaise (!) façon de simuler une boucle avec condition
d’arrêt
Etude de cas
Exemple d’utilisation de continue :
int i;
...
i = 0;
while (i < 100) {
++i;
if ((i % 2) == 0) continue;
// L’execution de la suite des instructions
// ne se fait pour les entiers impairs
Instructions;
...
}
while (true) {
Instruction 1;
...
if (condition_d_arret)
break;
}
autres instructions;
Question : quelle est la bonne façon d’écrire le code ci-dessus ?
Question : quelle est une meilleure façon d’écrire le code
ci-dessus ?
(on suppose que Instructions; ... ne modifie pas la valeur de i)
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 11 / 21
Programmation I – Cours 4 : Boucles et itérations – 12 / 21
Les structures de contrôle
Support MOOC
Concepts
centraux
Approfondissements
Etude de cas
Support MOOC
Concepts
centraux
Etude de cas
Approfondissements
les branchements conditionnels : si ... alors ...
if (condition)
instructions
Etude de cas
switch (expression) {
case valeur:
instructions;
break;
...
default:
instructions;
}
........................
if (condition 1)
instructions 1
...
else if (condition N)
instructions N
else
instructions N+1
I
Calcul de l’IMC revisité
les boucles conditionnelles : tant que ...
while (condition)
Instructions
do
Instructions
while (condition);
les itérations : pour ... allant de ... à ...
for (initialisation ; condition ; increment)
instructions
les sauts : break; et continue;
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Note : instructions représente une instruction élémentaire ou un bloc.
instructions; représente une suite d’instructions élémentaires.
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 14 / 21
Programmation I – Cours 4 : Boucles et itérations – 13 / 21
Support MOOC
Concepts
centraux
Etude de cas : IMC
Support MOOC
Concepts
centraux
Approfondissements
Etude de cas
Etude de cas : IMC
Approfondissements
Comment faire en sorte que l’on redemande les données à
l’utilisateur tant que l’IMC calculée n’est pas dans des bornes
acceptables (par exemple entre 5.0 et 65.0) ?
Etude de cas
Quel type de boucle ?
I
int main() {
double poids(74.5);
double taille(1.75);
une boucle for ?
+ On ne sait pas combien de fois la saisie va être incorrecte !
I
cout << "Entrez un poids (en kg) : ";
cin >> poids;
cout << "Entrez une taille (en m) : ";
cin >> taille;
une boucle while ?
+ On serait contraint à exécuter le code une fois pour rien ou
répéter la saisie des données avant le corps de la boucle !
I
double imc(poids / (taille * taille));
une boucle do while
+ répond ici à nos besoins
cout << "Pour "
<< poids
<< " kg et " << taille
<< " m, l’IMC est de " << imc
<< endl;
return 0;
}
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 15 / 21
Programmation I – Cours 4 : Boucles et itérations – 16 / 21
Support MOOC
Concepts
centraux
or ou and
Support MOOC
Concepts
centraux
Approfondissements
Approfondissements
Etude de cas
Etude de cas
Portée
On aboutit au code suivant :
int
Il est souvent difficile de correctement choisir entre la conjonction
and et la disjonction or. Quelques pistes :
I
main() {
constexpr double IMC_MIN(5.0);
constexpr double IMC_MAX(65.0);
double poids(74.5);
double taille(1.75);
tout d’abord que veut-on : que la condition soit vraie ou
qu’elle soit fausse ?
double imc(poids / (taille * taille)); // ATTENTION A LA PORTEE
do {
+ Ici on veut continuer tant qu’elle est vraie
I
cout << "Entrez un poids (en kg) : ";
cin >> poids;
cout << "Entrez une taille (en m) : ";
cin >> taille;
imc = poids / (taille * taille);
parfois il est plus facile de passer par la contraposée (sa
négation) :
+ Ici on veut s’arrêter dès que la condition est fausse ;
dès que l’IMC calculée est inférieure ou égale à 65.0 et est
supérieure ou égale à 5.0
}
while (imc > IMC_MAX or imc < IMC_MIN);
//... reste du programme
}
On veut donc continuer tant que l’IMC calculée supérieure à
65.0 ou est inférieure à 5.0
Mais attention ici à la portée de la variable imc. Il a été nécessaire
de déplacer sa déclaration en dehors de la boucle.
Prenez aussi soin d’éviter les valeurs codées «en dur»
c EPFL 2014
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Jamila Sam
& Jean-Cédric Chappelier
+ les valeurs minimale et maximale de l’IMC sont stockées
dans des constantes réutilisables
Programmation I – Cours 4 : Boucles et itérations – 18 / 21
Programmation I – Cours 4 : Boucles et itérations – 17 / 21
Support MOOC
Concepts
centraux
Aller plus loin
Support MOOC
Concepts
centraux
Approfondissements
Etude de cas
Aller plus loin (suite)
Approfondissements
Si l’on veut imposer un nombre limité d’échecs de saisie, voici une
solution possible :
int
// Apres la sortie de la boucle on veut donner un message informatif
Etude de cas
if (not (imc > IMC_MAX or imc < IMC_MIN))
{
cout << "Pour "
<< poids
<< " kg et " << taille
<< " m, l’IMC est de " << imc
<< endl;
}
else
{
cout << "Vous n’avez pas introduit des donnees correctes !" << endl;
}
main() {
constexpr double IMC_MIN(5.0);
constexpr double IMC_MAX(65.0);
constexpr int ESSAIS_MAX(3);
double poids(74.5);
double taille(1.75);
double imc(poids / (taille * taille));
int nb_essais(0);
do
{
return 0;
cout << "Entrez un poids (en kg) : ";
cin >> poids;
cout << "Entrez une taille (en m) : ";
cin >> taille;
imc = poids / (taille * taille);
++nb_essais;
c EPFL 2014
}
while ((imc > IMC_MAX or imc < IMC_MIN) and nb_essais <= ESSAIS_MAX);
// suite du programme a la page suivante
Jamila Sam
& Jean-Cédric Chappelier
}
+ Attention ici, pour les messages après la boucle, à bien
formuler la condition pour savoir pourquoi on est sorti de la
boucle
+ On voit déjà ici l’intérêt d’avoir utilisé des constantes !
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 19 / 21
Programmation I – Cours 4 : Boucles et itérations – 20 / 21
Support MOOC
Concepts
centraux
Pour préparer le prochain cours
Approfondissements
Etude de cas
I
Vidéos et quiz du MOOC semaine 4 :
I
I
I
I
I
I
I
Fonctions : introduction [16:07]
Fonctions : appels [09:35]
Fonctions : passage des arguments [09:29]
Fonctions : prototypes [05:56]
Fonctions : méthologie [10:21]
Fonctions : arguments par défaut et surcharge [10:25]
Le prochain cours :
I
de 15h15 à 16h (résumé et quelques approfondissements)
c EPFL 2014
Jamila Sam
& Jean-Cédric Chappelier
Programmation I – Cours 4 : Boucles et itérations – 21 / 21