1

Chapitre2 : Structures conditionnelles et répétitives

1 La notion de structure de contrôle.

Les structures de contrôle sont des instructions qui permettent de contrôler et d’orienter l’exécution
du programme.
L’exécution du programme se fait pas à pas, on dit, de façon séquentielle. On a souvent besoin de
rompre cette séquence d’exécution :
 Parfois on veut sauter certaines instructions : on dira d’elles que ce sont des instructions
conditionnelles.
 D’autres fois on a besoin de répéter certaines instructions : on dira que ces instructions sont
répétitives.
Les structures de contrôle confèrent aux machines “un comportement intelligent”, les rendent plus
intéressantes. Et contribuent à la résolution d’un certain nombre de problèmes.
Les structures de contrôles sont au nombre de deux :
– Les structures conditionnelles. Dites aussi séquentielles ou de choix.
– Les structures de répétition. On dit aussi structures itératives
Les structures de choix sont des instructions de contrôles qui permettent de choisir, parmi plusieurs
instructions, laquelle sera exécutée.
Le choix est fait sous condition. Une expression à valeur numérique servira de condition.
Elles existent sous quatre formes, sensiblement différentes :
 Les structures conditionnelles alternatives.
 Les structures conditionnelles simples.
 Les structures conditionnelles imbriquées, ou en cascade.
 Les structures de choix multiples.

2 Les structures conditionnelles simples.

Elles offrent le choix entre une instruction ou rien. On dira plutôt, que c’est une structure de
branchement conditionnel ; c.à.d. que si la condition est vraie, l’instruction est exécutée, sinon
l’instruction est ignorée.

2.1 Son algorithme.

Une structure conditionnelle simple est :

Si <condition> Alors
instruction(s)
Si la condition vaut 1 l’instruction(s) est exécuté, sinon le programme continue sans l’exécuter.

2.2 Son organigramme.

 Début

faux/false/0
Condition

vrai/true/1

Instructions

Fin

2.3 Sa syntaxe.

La traduction de l’algorithme précédent en langage C est :

if (expression)
instruction 1

Pour plus d’une instruction, l’usage du bloc {} devient necéssaire.

if (expression)
{
instruction 11;
instruction 12;
...
}

2.4 Un exemple.

Dans cet exemple, trois variables a, b et c sont saisies, le programme affichera la valeur maximale.

int a, b, c, max;
cout << "Entrez 3 Entiers : " << endl;
cin >> a >> b >> c;

max = a;
if(b > max) max = b;
if(c > max) max = c;

cout << "maximum : " << max;

On mémorise la variable a dans max. Si b est plus grand que a ; alors c’est b qui est mémorisé. Si c
est plus grand que a et b, alors c sera mémorisé dans max.
3 Les structures conditionnelles alternatives.
Elles offrent le choix entre deux instructions.

3.1 Son algorithme.

Formellement, la syntaxe d’une instruction conditionnelle alternative est

Si <condition> Alors
instruction(s) 1
Sinon
instruction(s) 2
La condition est une expression logique qui peut avoir pour valeur 0 ou 1. Elle est d’abord évaluée,
si elle vaut 1 c’est l’instruction 1 qui est exécutée si elle vaut 0 c’est l’instruction 2 qui sera exécutée.

3.2 Son organigramme.

Début

faux/false/0
Condition

vrai/true/1

Instructions 1 Instructions 2

Fin

3.3 Sa syntaxe.

La traduction de l’algorithme précédent en langage C est :

if (expression)
instruction 1
else
Instruction 2

Dans le cas où, plusieurs instructions seraient présentes, il serai impératif de les grouper au sein d’un
bloc {} ; de cette manière :

if (expression)
{
instruction 11;
instruction 12;
...
}
else
 {
instruction 21;
instruction 22;
...
}

Dans ces écritures :

If et else sont les mots-clés, traductions de Si et Sinon.
expression est une expression quelconque de type numérique, de valeur 0 ou 1.
Si elle est non nulle, ce sont les instructions 1 qui sont exécutées. Sinon ce sont les
instructions 2 qui le seraient.

3.4 Un exemple.

Appliquons la structure de choix dans le cas d’un programme qui lit 2 entiers au clavier et qui
affiche la plus grande des 2 valeurs :

int a, b;
cout << "entrez 2 nbres entiers : ";
cin >> a >> b;

if (a>b)
cout << "le maximum est: " << a << endl; // Instrunction 1
else
cout << "le maximum est: " << b << endl; // Instrunction 2
En saisissant les valeurs a = 5 et b = 1, par exemple, la condition a>b vaut 1 ; c’est l’expression 1
qui sera exécutée.

4 Les structures conditionnelles imbriquées

Cette forme de branchement conditionnel permet d’effectuer une suite de tests en cascade (les uns
après les autres), jusqu’à ce qu’à la première condition vraie. Si aucune n’est vraie, il exécute
l’instruction par défaut.

4.1 Son algorithme.

Si (condition 1) alors instructions 1

Sinon si (condition 2) alors instructions 2
… … … … …
Sinon si (condition N) alors instructions N
[Sinon instructionsDefaut]

Si la première condition vraie porte le numéro i, alors les instructions exécutées seraient les
instructions i. ensuite le programme, sort de la structure conditionnelle.
Si aucune condition n’est vraie, alors les instructionsDefaut seront exécutées.

Comme la dernière ligne de cette structure est facultative, si elle est absente, aucune instruction ne
serait exécutée dans le cas où toutes les conditions seraient fausses.

4.2 Son organigramme.

 Début
Fausse
Condition 1
Fausse
Vraie Condition
2 Fausse

Instruction(s) 1 Vraie Condition 3

Instruction(s) 2 Vraie

Instruction(s) 3

InstructionDefaut

Fin

Si la condition 1 est vraie alors les instructions 1 sont exécutées, et le programme ignore toutes les
autres instructions et va à la fin de si. Si elle est fausse, la condition 2 est évaluée ; si elle est vraie
les instructions 2 sont alors exécutées. Ainsi de suite. Si aucune des conditions n’est vraie, le
programme va à la ligne sinon (la dernière) et exécute les instructions par défaut.

4.3 Sa syntaxe.
if( condition_1)
instruction_1;
else if( condition_2)
instruction_2;
else if( condition_3)
instruction_3;
else if( condition_4)
instruction_4;
[else instructionDefaut;] // Facultatif

4.4 Un exemple.

Voici un programme qui lit la note d’un étudiant, et affiche le résultat de validation avec la mention
obtenue.
int N;
cout << "Entrer Note N, telle que 0<= N <=20" << endl;
cin >> N;
if( N < 0 || N > 20) cout << "Note Invalide " << endl;
else if ( N >= 16 ) cout << "Mention TB " << endl;
else if ( N >= 14 ) cout << "Mention B " << endl;
else if ( N >= 12 ) cout << "Mention AB " << endl;
else if ( N >= 10 ) cout << "Mention P " << endl;
else cout << "Module NV " << endl;

5 Les structures à choix multiples : switch

La structure de contrôle switch permet de faire un choix parmi plusieurs valeurs possibles, d’une
même expression.

5.1 Son algorithme

Si on en donnait une écriture algorithmique, celle-ci serait de la sorte :

SelonQue expression vaut

DébutSelonQue
Valeur1 : instructions 1
valeur2 : instructions 2
//...
valeurn : instructions n
sinon : instructionDefaut
FinSelonQue

Qu’on interprète en disant : selon la valeur de expression, c.à.d. que si expression est égale
à valeur1, alors les instruction1 seront exécutées. Sinon, si expression est différente
de valeur1, on passe à valeur2 et on refait le même raisonnement. Et ainsi de suite. Dans le
cas où toutes les valeurs sont différentes de expression alors les instructions par défaut
seront exécutées.

5.2 Son organigramme.

Début

1 Avec break
Variable Valeur1 instructions1

0 Sans break
1 Avec break
Valeur2 Instructions2

0 Sans break
1 Avec break
Valeurn instructionsn

0 Sans break

Instructions Avec break

Défaut
Defaut

Fin

Pour le cas de switch, il n y a pas de condition explicite, mais il y a une comparaison entre la
variable et la valeur, en cas d’occurrence d’égalité, il y a branchement vers les instructions.

5.3 Sa syntaxe.

switch (Variable)
{
case Valeur_1 : instructions_1
[break;] // facultatif
case Valeur_2 : instructions_2
[break;] // facultatif
 case Valeur_n : instructions_n
[break;] // facultatif
default : instructions_def
[break;] // facultatif
}

switch, case, default sont des mots clés du C++.

variable ou de façon générale, une expression entière doit être de type
char, int, bool ou long c'est-à-dire un type entier.
Valeur_i doit être une constantes entières : 'a', 0, 1234, etc.

Le compilateur vérifie, dans l’ordre, si variable est égale à une des constantes, dans lequel cas les
instructions correspondantes sont exécutés.
Si break est absent, les instructions qui suivent sont aussi exécutées. Si break est présent, le
programme va vers la fin de la structure.
Si aucune des constantes n’est égale à la variable de switch alors les instructions de default sont
exécutées.

5.4 Exemples.

Supposons que l’on veuille vérifier si une lettre saisie au clavier est une voyelle ou non ?
char c ;
cout << "Entrez une lettre : ";
cin >> c ;
switch(c)
{
case 'a' :
case 'e' :
case 'i' :
case 'o' :
case 'u' :
case 'y' : cout << c << " est une voyelle" << endl;
break;
default : cout << c << " n\'est pas une voyelle" << endl;
}

Vérifier si un nombre entier est pair ou impair ?

int n ;
cout << "Entrez une entier : ";
cin >> n ;

switch(n%2)
{
case 0 : cout << n << " est pair";
break;
case 1 : cout << n << " est impair";
}

6 Les structures répétitives /itératives.

Les structures répétitives ou simplement boucles permettent de répéter, plusieurs fois, un groupe
d’instructions. Elles sont constituées d’une instruction ou d’un groupe d’instructions à exécuter, et
d’une expression fournissant une condition.
Tant que cette condition est vraie ; on répète l’exécution du groupe d’instructions ; dès que la
condition devient fausse l’exécution s’arrête.
L’ordre dans lequel on place les instructions et la condition offre deux possibilités d’usage des
boucles, avec très peu de différences entre elles:
 Si la condition précède les instructions, on a une boucle de forme : tant que …faire…
Dans ce cas le test est effectué avant d’exécuter les instructions.
Le mot clef, qui lui correspond dans le langage C/C++ est while.
 Si au contraire les instructions précèdent la condition, on est en présence dune boucle de forme:
faire…tant que…
Dans ce cas l’exécution des instructions se fait avant de faire le test.
Le mot clef, qui lui correspond est do … while.

6.1 Forme tant que … faire / while

6.1.1 Algorithme tant que … faire

TantQue <condition>
DebutTantQue
Instructions
FinTantQue

Tant que la condition est vraie on exécute les instructions. Dès que la condition devient fausse on va
à la ligne du programme situé après tant que, sans exécuter les instructions.

6.1.2 Son organigramme.

Début

0/false
Condition

1/true

Instructions

Fin

6.1.3 Sa syntaxe
En C/C++ la structure while est la traduction de tantQue, elle a la syntaxe suivante :

while(condition)

instruction

Où :
Condition est une expression logique, elle doit être entre parenthèses.
Instruction instruction à exécuter.
Dans le cas de la présence de plusieurs instructions, on place les instructions entre accolades.

while(condition)
{
Instructions
}
6.1.4 Exemples.
Exemple 1 : Une structure while qui affiche les nombres entiers compris entre deux nombres a et b
tels que a < b.
#include<iostream>
using namespace std;

int main()
{
int a = 10, b = 20, i;
i = a;
while(i <= b)
{
cout << i << endl;;
i++;
}
cout << "Valeur de i en sortie de boucle : " << i;

return 0;
}

Il est à noter que la valeur de i à la sortie de la boucle est 21. Puisque b vaut 20 ; la condition ne
sera fausse qu’à partir de i = 21.

Exemple 2 : Lire 5 valeurs entières au clavier.

int a, compteur = 0;
while ( compteur < 5 )
{
cin >> a;
compteur++;
}
cout << "Valeur de compteur est : " << compteur;

La variable ‘compteur’ varie de 0 à 4, avec à chaque itération une lecture de a.

Quand ‘compteur’ vaut 5, on sort de la boucle.

Exemple 3 : Afficher et compter les diviseurs d’un nombre n saisi au clavier.

int n, i, compt = 0;
cin >> n;
i=1;
while(i<=n)
{
if(n%i==0)
{
cout << "i= " << i << " divise " << n << endl;
compt++;
}
i++;
}
Ce même exemple peut servir pour chercher si n est un nombre premier ou non. Il suffit de
contrôler si le nombre de diviseurs est égal ou supérieur à 2.

Exemple 4 : lire des nombres réels positifs ou nuls, dès qu’un nombre négatif est saisi la lecture
s’arrête.

float x;
x=1.;
while(x>=0.)
{
cin >> x;
}

Pour que l’on puisse accéder la première fois à l’intérieur de la boucle, il faut bien initialiser x à une
valeur non négative quelconque.

On peut ensuite modifier ce programme pour qu’il calcule la moyenne des valeurs saisies.
float x,som=0.;
int compt=0;

x=1.;
while(x>=0.)
{
cin >> x;
if (x>=0.)
{
compt++;
som+=x;
}
}
if(compt) cout << "la moyenne est : " << som/compt;

6.2 Forme faire … Tant que / do … while.

6.2.1 Algorithme faire … tant que.
La différence annoncée entre la forme tant que …faire et faire… tant que était dans l’ordre de
placement de la condition et des instructions à exécuter. L’algorithme de faire …tant que place les
instructions avant la condition. Voici son algorithme :

Faire

instructions

TantQue(condition)

Les instructions sont exécutées, au moins, une fois. Leur exécution plus d’une fois dépendra de l’état
de la condition.

6.2.2 Son organigramme.

 Début

Instructions

Condition
1/true
0/false

Fin

6.2.3 Sa syntaxe
La traduction de Faire … TantQue dans le langage C/C++ est do…while() ;

do

instruction

while(condition);

Attention au point-virgule présent après la condition. La condition entre parenthèse doit être une
expression logique. Par ailleurs, dans le cas de la présence de plusieurs instructions, il faut les placer
entre accolades.

Do {

instructions

} while(condition);

6.2.4 Exemples.
D’une manière générale, tout ce qui est écrit avec une des deux formes de boucle peut être réécrit
avec l’autre moyennant des adaptations mineures.
Exemple 1 : Reprenons l’exemple 4 précédent.
Il s’agit de lire, au clavier, des nombres réels tant qu’ils sont positifs ou nuls ; dès qu’un nombre
négatif est saisi la lecture doit s’arrêter. Calculer ensuite la moyenne des nombres saisis.

float x, moy, som;

int compt = 0;

do
{
cin >> x;
if (x>=0.)
{
compt++;
 som+=x;
}
} while(x>=0.);
if(compt) cout << "la moyenne est : " << som/compt;

Comme on peut le constater, on lit d’abord x et ensuite on teste son signe. Selon sa valeur on
revient faire une autre lecture ou on sort de la boucle. Il n’a pas été nécessaire d’initialiser x comme
dans le cas de while.
Exemple 2 :
Afficher tous les multiples pairs de 3 inferieurs à 100.
int n = 100, i = 1;

do
{
if (i%2 == 0 && i%3 == 0) cout << i << " est pair et mult de 3" <<endl;
i++;
}while( i <= 100 );

6.3 Forme for

La forme des structures répétitives utilisant for s’apparente beaucoup à celle utilisant while, en ce
sens que le test y est effectué avant l’exécution du bloc d’instructions ; en plus d’un réarrangement
des autres éléments de la structure.

6.3.1 Syntaxe de for

for a la syntaxe suivante dans le cas général de présence de plusieurs instructions:
for ([expression1] ; [expression2] ; [expression3])
{
instructions
}
Remarque : les crochets [] ne font pas partie de la syntaxe, mais ils indiquent que ce qu’il y a
dedans est facultatif, et qu’il peut être omis.

Nature et sens des expressions incluses dans for :

 expression1 : est exécutée une fois et une seule, tout au début de la première itération. Pour
cela, on l’utilisera pour l’initialisation d’une variable dite de contrôle, qui servira dans la
condition.
 expression2 : elle servira de contrôle pour la boucle. Si vrai on exécute les instructions, si
fausse on quitte la boucle.
 expression3 : elle est exécutée à la fin de chaque itération. On peut y modifier la valeur de
la variable de contrôle, comme par incrémentation ou décrémentation par exemple.

6.3.2 Exemple.
On va prendre un exemple avec un cas de boucle fait avec la forme while que l’on convertie en
forme for. On pourrait écrire un programme qui affiche 5 fois le mot « hello » en utilisant une
variable de contrôle qui est un entier i :

Avec while avec for

int i; int i;
i = 0;
while( i < 5 ) for( i=0; i < 5; i++ )
{ {
cout << "Hello ! " << i << endl; cout << "Hello ! " << i << endl;
i++;
} }

On remarquera que :
 L’expression1 : i = 0 correspond à l’initialisation.
 L’expression2 : i < 5 correspond à la condition.
 L’expression3 : i++ correspond à l’incrémentation.
Pour montrer que la présence des expressions, dans for( ; ; ) est facultative, on peut apporter
ces quelques modifications, au code ci-dessus :
int i;
i = 0;
for( ;i < 5; )
{
cout << "Hello ! " << i << endl;
i++;
}

Ce programme s’exécutera normalement.la ressemblance avec la forme while devient évidente.

On peut également supprimer la condition i < 5. La syntaxe sera toujours correcte.
Quand la condition est absente, par défaut, le langage la considère comme vraie. On va obtenir
une boucle infinie. Cela n’a pas beaucoup d’intérêt pratique.
6.3.3 Opérateur séquentiel.
Selon le contexte, l’opérateur virgule (,) peut servir de séparateur. C’est le cas des lignes de
déclaration :
int a, b, c;
Dans cet exemple, l’opérateur (,) sert à séparer les différentes variables.
Dans d’autres cas, il peut servir comme opérateur séquentiel :

L’opérateur séquentiel (,) permet de regrouper des sous-expressions dans une seule expression. Les
sous-expressions y apparaissent sous forme d’une liste, sur une même ligne. Ces sous-expressions
sont évaluées en séquence (à la suite les unes après les autres). La valeur d'une liste d'expressions est
celle de la dernière de la liste.

Exemple, soit les expressions suivantes :

i++;
j += 5;
k = i + 2 * j;
Si on écrivait

i++, j += 5, k = i + 2 * j;

On obtiendrait un opérateur séquentiel avec (,) dans lequel les expressions précédentes sont
devenues des sous expressions d’une instruction terminée par (;).
L’expression i++ est d’abord évaluée, suivie de j += 5, et k = i + 2 * j est évaluée en
dernier. C'est-à-dire que l’associativité est de gauche vers la droite.
Il ne faut pas confondre cette écriture avec cette autre écriture :
i++; j += 5; k = i + 2 * j;
Laquelle à l’évidence est équivalente à la première, où les expressions occupaient une ligne chacune.
Ici, les trois sont sur la même ligne, mais chacune est terminée par un point-virgule.
Un autre exemple pour montrer la deuxième partie de la définition : La valeur d'une liste
d'expressions est celle de la dernière de la liste.
i = (j++, i+3, k+1);
Dans cet exemple, la variable i prendra la valeur k+1 tout simplement ; mais auparavant, la sous
instruction j++ sera exécutée, suivie de l’expression i+3 et enfin k+1. Comme k+1 est la dernière
expression, alors i sera égale à k+1. Notez que la présence des parenthèses est déterminante, sinon
la séquence précédente aura une autre interprétation.
L’usage de l’opérateur séquentiel se rencontre particulièrement dans les structures de contrôle de
répétition for.
6.3.4 Opérateur séquentiel (,) dans for.
Souvent, dans l’usage de la forme for, on a besoin de plus qu’une instruction dans l’initialisation
ou dans l’incrémentation. Dans ces cas l’operateur séquentiel est très utile.
Prenons un exemple : Deux variables i et j, initialement à 0 et 60 respectivement. i augmente d’un
pas de 2, et j diminue d’un pas de 3. Où se trouve l’intersection ?
Pour répondre, on écrit le code suivant :

int i, j;

for( i=0, j=60; i < j; i=i+2, j=j-3 )

{
cout << "i= " << i << " j= " << j << endl;
}

Notez l’utilisation de (,) dans les initialisations et les incrémentations. Le critère d’arrêt de boucle,
est que i doit rester inferieur à j. Dès que ce n’est plus vrai, on arrête la boucle.
A l’exécution, on a la réponse ; l’intersection se trouve dans les intervalles [22,24] pour i et [24,27]
pour j.

7 Les branchements inconditionnels : continue, break et goto.

Ces instructions vont faire le branchement vers un endroit précis du programme sans aucune
condition préalable.
Elles vont ainsi interrompre l’exécution pas à pas du programme, et générer un saut de quelques
lignes.
La lecture par l’homme (pas pour la machine), du code du programme, devient un exercice difficile
sinon impossible.
La programmation, dite structurée, évite ce genre d’instructions, ou du moins, en limite l’usage.
Ces instructions sont : break, continue et goto.
Les instructions continue et break ont un usage contrôlé, pourvu qu’on les utilise dans des
structure de contrôle comme les boucles. Les effets seront limités à cette seule structure.
L’instruction goto est vivement déconseillée, car elle permet de faire des sauts de n’importe, vers
n’importe dans le programme. Elle existe toujours dans les compilateurs, pour des raisons
historiques, mais aussi pour des usages orientés machines.
7.1 continue

Si on limite son usage aux boucles, les effets de cette instruction sont :
Continue renvoie à la fin de l’itération en cours en sautant toutes les instructions qui la suivent.
Prenons l’exemple d’un programme qui afficherait les diviseurs d’un entier N, ignorerait les non
diviseurs. Les diviseurs 1 et N étant connus d’avance.

6 int N, i, compt;
7
8 cout << "Entrez un nombre : ";
9 cin >> N;
10
11 for ( compt=0, i = 2; i < N; i++ )
12 {
13 if ( N % i != 0 ) continue;
14 cout << i << " est diviseur de " << N << endl;
15 compt++;
16 }
17 cout << "Nbre de diviseurs = " << compt;

A la ligne 13, il y a l’instruction continue. Si le reste de la division de N par i est non nul,
continue est activée. Alors les lignes 14 et 15 sont sautées, on reste dans la boucle mais on passe
dans le pas suivant, c.à.d. à i+1.

7.2 break.

Utilisée dans une boucle, break fait sortir de la boucle, en sautant toutes les instructions qui la
séparent de l’accolade fermant le bloc.
Exemple : étant donné un nombre entier N, on écrit un programme qui permet de dire s’il est un
nombre premier, ou non ?
Pour cela, on passe tous les nombres de 2 à N-1, si N possède un seul diviseur, il ne sera pas
premier. Si on rencontre un tel diviseur, on affiche un message et on utilise break pour arrêter la
boucle.
Une fois en dehors de la boucle, on teste i, s’il a atteint N, c’est qu’il n y a pas de diviseur de N. on
affiche un message.

6 int N, i, compt;
7
8 cout << "Entrez un nombre : ";
9 cin >> N;
10
11 for ( i = 2; i < N; i++ )
12 {
13 if ( N % i == 0 )
14 {
15 cout << i << " est diviseur de " << N << endl;
16 cout << N << " n\'est pas un nombre premier";
17 break;
18 }
19 }
20 if(i>=N) cout << N << " est un nombre premier ";
21

7.3 goto.

Avant de pouvoir utiliser l’instruction goto, on aura besoin de savoir ce qu’est une étiquette.
– Etiquette/Label.
 Une étiquette –label en anglais- est une numérotation des lignes d’un programme.
Une étiquette doit porter un nom, qui respecte les règles des identificateurs.
Elle doit être insérée, à l’endroit du programme que l’on voudrait étiqueter, suivie du caractère
spécial (:).
Le nom donné à une étiquette n’a pas besoin d’être déclaré. Les étiquettes possèdent un espace
de noms propre.
– Exemples d’étiquettes.
L0, L1 et L2, dans le programme qui suit sont des étiquettes.
– goto.
Elle s’utilise avec la syntaxe :
goto etiquette :
goto L1 : // par exemple
Elle opère un branchement non conditionnel de la ligne d’appel, vers l’étiquette, sans aucune
formalité.

Pour illustrer ces propos, on va donner comme exemple, la conception d’une boucle avec goto,
sans avoir besoin, ni de while ni de for.

Cette boucle sera faite pour i allant de : i=0 à i=N, N étant un entier quelconque.
6 L0:
7 int N, i, compt;
8
9 cout << "Entrez un nombre >0 : ";
10 cin >> N;
11
12 i = 0;
13 L1:
14 cout << "valeur de i : " << i << endl;
15 /// + autres instructions
16 i++;
17
18 if ( i < N ) goto L1;
19 else goto L2;
20 L2:
21 cout << "Message: sortie de boucle" << endl;
22

Dans la ligne n°18 est présente l’instruction goto. Tant que i reste inférieur à N, goto renvoie vers
l’étiquette L1 (boucle), dès que i devient égale à N, goto renvoie vers L2 (hors boucle).