La structure conditionnelle if

La structure conditionnelle if permet de réaliser un test et d'exécuter une instruction ou non selon le résultat de ce test. Sa syntaxe est la suivante :

if (test) opération;

où test est une expression dont la valeur est booléenne ou entière. Toute valeur non nulle est con- sidérée comme vraie. Si le test est vrai, opération est exécuté. Ce peut être une instruction ou un bloc d'instructions. Une variante permet de spécifier l'action à exécuter en cas de test faux :

if (test) opération1; else opération2;

Note : Attention ! Les parenthèses autour de test sont nécessaires !

Les opérateurs de comparaison sont les suivants :

Tableau 2-1. Opérateurs de comparaison == Egalité != Inégalité < Infériorité > Supériorité <= infériorité ou égalité >= supériorité ou égalité

Les opérateurs logiques applicables aux expressions booléennes sont les suivants :

Tableau 2-2. Opérateurs logiques && et logique

|| ou logique ! négation logique

Il n'y a pas d'opérateur ou exclusif logique. Exemple 2-1. Test conditionnel if

if (a<b && a!=0) {

min=a;

nouveau_min=1; }

2.2. La boucle for

La structure de contrôle for est sans doute l'une des plus importantes. Elle permet de réaliser toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d'une variable de con- trôle. Sa syntaxe est la suivante :

for (initialisation ; test ; itération) opération;

où initialisation est une instruction (ou un bloc d'instructions) exécutée avant le premier par- cours de la boucle du for. test est une expression dont la valeur déterminera la fin de la boucle.

itération est l'opération à effectuer en fin de boucle, et opération constitue le traitement de la boucle. Chacune de ces parties est facultative.

La séquence d'exécution est la suivante :

initialisation

test : saut en fin du for ou suite opération

itération retour au test fin du for.

Exemple 2-2. Boucle for

somme = 0;

for (i=0; i<=10; i=i+1) somme = somme + i;

Note : En C++, il est possible que la partie initialisation déclare une variable. Dans ce cas, la variable déclarée n'est définie qu'à l'intérieur de l'instruction for. Par exemple,

for (int i=0; i<10; ++i);

est strictement équivalent à :

{

int i;

for (i=0; i<10; ++i); }

Cela signifie que l'on ne peut pas utiliser la variable i après l'instruction for, puisqu'elle n'est définie que dans le corps de cette instruction. Cela permet de réaliser des variables muettes qui ne servent qu'à l'instruction for dans laquelle elles sont définies.

Note : Cette règle n'est pas celle utilisée par la plupart des compilateurs C++. La règle qu'ils

Chapitre 2. Les structures de contrôle

reste déclarée après cette instruction. La différence est subtile, mais importante. Cela pose assurément des problèmes de compatibilité avec les programmes C++ écrits pour ces compilateurs, puisque dans un cas la variable doit être redéclarée et dans l'autre cas elle ne le doit pas. Il est donc recommandé de ne pas déclarer de variables dans la partie

initialisation des instructions for pour assurer une portabilité maximale.

2.3. Le while

Le while permet d'exécuter des instructions en boucle tant qu'une condition est vraie. Sa syntaxe est la suivante :

while (test) opération;

où opération est effectuée tant que test est vérifié. Comme pour le if, les parenthèses autour du test sont nécessaires. L'ordre d'exécution est :

test opération

Exemple 2-3. Boucle while

somme = i = 0; while (somme<1000) {

somme = somme + 2 * i / (5 + i); i = i + 1;

}

2.4. Le do

La structure de contrôle do permet, tout comme le while, de réaliser des boucles en attente d'une condition. Cependant, contrairement à celui-ci, le do effectue le test sur la condition après l'exécu- tion des instructions. Cela signifie que les instructions sont toujours exécutées au moins une fois, que le test soit vérifié ou non. Sa syntaxe est la suivante :

do opération; while (test);

opération est effectuée jusqu'à ce que test ne soit plus vérifié. L'ordre d'exécution est :

opération test Exemple 2-4. Boucle do p = i = 1; do { p = p * i; i = i +1; } while (i!=10);

2.5. Le branchement conditionnel

Dans le cas où plusieurs instructions différentes doivent être exécutées selon la valeur d'une va- riable de type intégral, l'écriture de if successifs peut être relativement lourde. Le C/C++ fournit donc la structure de contrôle switch, qui permet de réaliser un branchement conditionnel. Sa syn- taxe est la suivante :

switch (valeur) { case cas1: [instruction; [break;] ] case cas2: [instruction; [break;] ] ⋮ case casN: [instruction; [break;] ] [default: [instruction; [break;] ] ] }

valeur est évalué en premier. Son type doit être entier. Selon le résultat de l'évaluation, l'exécu- tion du programme se poursuit au cas de même valeur. Si aucun des cas ne correspond et si de- fault est présent, l'exécution se poursuit après default. Si en revanche default n'est pas pré- sent, on sort du switch.

Les instructions qui suivent le case approprié ou default sont exécutées. Puis, les instructions du

cas suivant sont également exécutées (on ne sort donc pas du switch). Pour forcer la sortie du

switch, on doit utiliser le mot-clé break. Exemple 2-5. Branchement conditionnel switch

i= 2; switch (i) {

case 1:

case 2: /* Si i=1 ou 2, la ligne suivante sera exécutée. */ i=2-i;

break; case 3:

i=0; /* Cette ligne ne sera jamais exécutée. */ default:

break; }

Chapitre 2. Les structures de contrôle

2.6. Le saut

Le C/C++ dispose d'une instruction de saut, permettant de poursuivre l'exécution du programme en un autre point. Bien qu'il soit fortement déconseillé de l'utiliser, cette instruction est nécessaire et peut parfois être très utile, notamment dans les traitements d'erreurs. Sa syntaxe est la suivante :

goto étiquette;

où étiquette est une étiquette marquant la ligne destination dans la fonction. Les étiquettes sont simplement déclarées avec la syntaxe suivante :

étiquette:

Les étiquettes peuvent avoir n'importe quel nom d'identificateur.

Il n'est pas possible d'effectuer des sauts en dehors d'une fonction. En revanche, il est possible d'ef- fectuer des sauts en dehors et à l'intérieur des blocs d'instructions sous certaines conditions. Si la destination du saut se trouve après une déclaration, cette déclaration ne doit pas comporter d'initia- lisations. De plus, ce doit être la déclaration d'un type simple (c'est-à-dire une déclaration qui ne demande pas l'exécution de code) comme les variables, les structures ou les tableaux. Enfin, si, au cours d'un saut, le contrôle d'exécution sort de la portée d'une variable, celle-ci est détruite.

Note : Ces dernières règles sont particulièrement importantes en C++ si la variable est un objet

dont la classe a un constructeur ou un destructeur non trivial. Voir le Chapitre 8 pour plus de détails à ce sujet.

Autre règle spécifique au C++ : il est impossible d'effectuer un saut à l'intérieur d'un bloc de code en exécution protégée try {}. Voir aussi le Chapitre 9 concernant les exceptions.