Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++

Programmation Orientée Objet en C++
3ème Partie: Instructions de Contrôle d’Exécution

Fabio Hernandez
Fabio.Hernandez@in2p3.fr

Vue d'Ensemble
Notions de base
Types, variables, opérateurs
Contrôle d'exécution
Fonctions
Mémoire dynamique
Qualité du logiciel
Evolution du modèle objet
Objets et classes
Fonctions membres
Classes génériques
Héritage
Polymorphisme
Héritage multiple
Entrée/sortie

POO en C++: Contrôle d’Exécution 78 © 1997-2003 Fabio HERNANDEZ

Table des Matières

Instructions de Sélection (if, switch)
Instructions d’Itération (while, for, do)
Instruction de Rupture (break, continue)


Instructions de Sélection: if

Forme générale
if (condition)
instruction
if (condition) {
instruction 1
instruction 2
....
instruction n
}


Instructions de Sélection: if (suite)

Forme générale (suite)
if (condition)
instruction 1
else
instruction 2

if (condition) {
instruction 1
....
instruction n
}
else {
instruction 1
....
instruction n
}



Exemples
une seule instruction
if (temperature > 50.0)
cout << "this is getting HOT..." << endl;
plusieurs instructions
if (temperature > 90.0) {
threshold = temperature;
cout << "WARNING: evacuation is inminent" << endl;
}


La condition est une expression qui produit une valeur de faux (zéro) ou
vraie(non zéro)
Un entier ou un pointeur peuvent être utilisés comme conditions
Exemple
int count;
if (count){
// do something
}
est équivalent à
if (count != 0) {
// do something
}
De façon similaire pour les pointeurs
int* aPointer;
if (aPointer) // equivalent to if (aPointer != 0)
// do something



Rappel 1: les expressions comprenant des opérateurs logiques
&& (ET) et || (OU) sont évaluées de gauche à droite et
uniquement le nombre de composants nécessaires pour
déterminer la valeur de vérité de la condition sont évalués
Rappel 2: on ne peut pas déréférencer un pointer nul
On peut donc écrire
int* aPointer;
if (aPointer && (*aPointer > 100)) {
// do something
}
Si aPointer == 0 la deuxième partie de la condition n’est pas
évaluée



Parfois
un if simple comme
if (a <= b)
min = a;
else
min = b;
peut être mieux exprimé par
min = (a <= b) ? a : b;
à utiliser uniquement pour des expressions simples
autrement, le code peut devenir illisible


Instructions de Sélection: switch

Une suite de if...else peut être écrite plus simplement à
l’aide de l’instruction switch
Exemple: déterminer le nombre d’occurrences des lettres ‘a’ et ‘e’
dans un texte
Avec if
char letter;
int aCounter=0;
int eCounter=0;
int other=0;
...
if (letter == ‘a’)
++aCounter;
else if (letter == ‘e’)
++eCounter;
else
++other;


Instructions de Sélection: switch (suite)
Avec switch
switch (letter) {
case ‘a’:
++aCounter;
break;

case ‘e’:
++eCounter;
break;

default:
++other;
break;
}


Exemple: déterminer le nombre de voyelles dans un texte
int vowelCounter = 0;
int other = 0;
switch (letter) {
case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’:
++vowelCounter;
break;

default:
++other;
break;
}



Attention: chaque entrée case dans un switch doit être
delimitée, autrement l’execution continue sequentiellement
Exemple
int value;
....
switch (value) { // WARNING: no break
case 1:
cout << "entering case 1" << endl;
case 2:
default:
cout << "unknown value" << endl;
}


Si au moment d’executer le switch, la valeur de value est 1, le
résultat est
entering case 1
entering case 2
unknown value


Comparez contre
int value;
....
switch (value) {
case 1:
break;

case 2:
break;

default:
cout << "unknown value" << endl;
break;
}


Contrôle d'Avancement



Instructions d’Itération: while

Forme générale
while (condition)
instruction
while (condition) {
instruction 1
...
instruction n
}
Séquence d'exécution:
evaluation de la condition
exécution des instructions du corps si la condition est vraie
Si la première évaluation de la condition donne faux, les
instructions du corps ne sont jamais exécutées


Instructions d’Itération: while (suite)

Etant donné:
typedef float Temperature;
const int NumRooms = 100;
Temperature room[NumRooms];
Exemple 1: donner une valeur initiale à toutes les positions du
tableau room
Solution 1:
int roomNumber=0;
const Temperature InitialTemp = 15.0;
while (roomNumber < NumRooms) {
room[roomNumber] = InitialTemp;
roomNumber += 1;
}


Solution 2
roomNumber++;
}
Solution 3
while (roomNumber < NumRooms)
room[roomNumber++] = InitialTemp;



Exemple 2: chercher les valeurs maximum et minimum dans le
tableau room
#include <float.h>
int roomNumber=0;
Temperature max = FLT_MIN;
Temperature min = FLT_MAX;
if (room[roomNumber] > max)
max = room[roomNumber];
else if (room[roomNumber] < min)
min = room[roomNumber];
roomNumber++;
}


Instructions d’Itération: for

Forme générale
for (init-expresssion; condition; expression)
instruction
for (init-expresssion; condition; expression) {
instruction 1
...
instruction n
}
init-expression est executé une fois avant de commencer
la boucle
si l’évaluation de condition est vraie le corps du for est
exécuté
expression est executé à chaque itération, après le corps


Instructions d’Itération: for (suite)

La condition doit être évaluée vrai après l’exécution de init-
expression pour que la boucle soit exécutée au moins une fois
Exemples: etant donné:
typedef float Temperature;
const int NumRooms = 100;
Temperature room[NumRooms];
Exemple 1: donner une valeur initiale à toutes les positions du
tableau room
Solution 1:
int roomNumber;
const Temperature InitialTemp = 15.0;
for (roomNumber=0; roomNumber < NumRooms; ++roomNumber)



Exemple 2: chercher les valeurs maximum et minimum dans le
tableau room
Solution 1
#include <float.h>
int roomNumber;
Temperature max = FLT_MIN;
Temperature min = FLT_MAX;
for(roomNumber=0; roomNumber < NumRooms; ++roomNumber){
if (room[roomNumber] > max)
max = room[roomNumber];
else if (room[roomNumber] < min)
min = room[roomNumber];
}



Une boucle sans fin peut être écrite
for (;;) {
// do something forever
}
init-expression et expression peuvent être composées de
plusieurs instructions, comme dans...
for (i=0, j=100; array[i] < max; i++, j--)
...ou peuvent ne pas exister
int i=0;
int j=100;
for (; array[i] < max; i++, j--) // null init-expression


Instructions d’Itération: do

Forme générale
do {
instruction 1
...
instruction n
} while (condition);
La condition est évaluée après l’exécution du corps
La boucle est donc exécutée au moins une fois


Instructions de Rupture: break

Termine l’exécution du for, while, do ou switch le plus interne
L’exécution reprend immediatement après le bloc terminé
Exemple: déterminer l’occurrence d’une valeur particulière dans
un tableau; si trouvé écrire sa position
const int ArraySize = 200;
int array[ArraySize];
const int Target = 3456;
int i;
.....
for (i=0; i < ArraySize; i++)
if (array[i] == Target) Rupture
break; d'exécution de la
if (i == ArraySize) boucle
cout << "Not found" << endl;
else
cout << "Target found at position " << i << endl;


Instructions de Rupture: continue

Termine l’exécution de l’itération courante du for, while ou
do le plus interne
Dans le cas du while et do, l’exécution reprend avec
l’évaluation de la condition
Dans le cas du for, l’exécution reprend avec l’exécution de
expression


Instructions de Rupture: continue (suite)

Exemple: modifier toutes les positions d’un tableau si sa valeur
se trouve dans un intervalle donné
const int ArraySize = 200;
int array[ArraySize];
const int Start = 5000;
const int End = 10000;
.....
for (int i=0; i < ArraySize; i++) {
// Do we need to modify this value?
if ((array[i] < Start) || (array[i] > End))
continue; // nothing to do with this position

// modify this position
array[i] /= 2;
}


Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++

Contenu connexe

Tendances (20)

Similaire à Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++ (6)

Partie 3: Contrôle d'Exécution — Programmation orientée objet en C++