Page - 1/13

Chapitre 5 : Les structures

conditionnelles et les structures
ré pé titives
Table of Contents
Introduction............................................................................................................................................. 1
I. Les structures conditionnelles ......................................................................................................... 2
1. Branchement conditionnel if … else ............................................................................................ 2
2. Branchement if sans else............................................................................................................. 2
3. Les tests imbriqués ...................................................................................................................... 3
4. Les opérateurs conditionnels ...................................................................................................... 3
5. Les tests multiples (switch) ......................................................................................................... 4
II. Les structures répétitives ................................................................................................................ 5
1. La boucle while ............................................................................................................................ 5
2. La boucle do…while ..................................................................................................................... 7
3. La boucle for ................................................................................................................................ 7
4. Les boucles imbriquées ............................................................................................................. 10
III. Les instructions de branchement inconditionnel : continue, break, goto ............................... 11
1. Branchement inconditionnel break........................................................................................... 11
2. Branchement inconditionnel continue...................................................................................... 11
3. Branchement non conditionnel goto ........................................................................................ 12

Introduction
On appelle instruction de contrôle toute instruction qui permet de contrôler le fonctionnement d’un
programme. Parmi les instructions de contrôle, on distingue les instructions de branchement
conditionnel et les boucles. Les instructions de branchement permettent de déterminer quelles
instructions seront exécutées et dans quel ordre.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 2/13

I. Les structures conditionnelles

1. Branchement conditionnel if … else

• Syntaxe :
if (expression)
bloc instruction1 ;
else
bloc instruction2;

 Si expression fournit une valeur différente de 0, alors le bloc instruction1 est exécuté
sinon le bloc instruction2 sera exécuté.
 La partie expression peut être :
o Une variable numérique
o Une expression fournissant un résultat numérique
 La partie bloc instruction peut désigner :
o Une seule instruction terminée par un point virgule.
o Un ensemble d’instructions mis entre deux accolades.
• Exemple 1:
if (a>b)
max = a;
else max = b;

• Exemple 2:
if (A – B)
printf("%d est différent de %d", A,B) ;
else
printf("%d est égal à %d", A,B) ;

2. Branchement if sans else

• La forme la plus simple est :
if ( expression )
instruction
 Si l’expression est vraie alors on exécute le bloc d’instructions sinon on passe à la suite
du programme.
 Chaque instruction peut être un bloc d’instructions.
• Exemple :
if ((c = getchar( )) ! = ‘A’)
printf("le caractère saisi n’est pas A");
• Exemple: Ecrire un programme qui permet de saisir un entier x et qui affiche ‘’supérieur à
100 ‘’ s’il est > 100.
void main ( ) {
int x ;
printf("donnez un entier") ;
scanf("%d",&x) ;
if (x>100)
printf("Supérieur à 100");
}

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 3/13

3. Les tests imbriqués

• Syntaxe :
if (expression 1)
{
<bloc instruction 1>;
}
else
if (expression 2)
{
<bloc instruction 2>;
}
else
if (expression 3)
{
<bloc instruction 3>;
}
else
….
if (expression N)
{
<bloc instruction N>;
}
else

<bloc instruction N+1>;

• Le dernier else est facultatif.
• Les expressions <expression1>,…, <expression N> sont évaluées du haut vers le bas jusqu’à
ce que l’une d’elles soit différente de 0. Le bloc d’instructions y lié est alors exécuté et le
traitement de la structure conditionnelle sera terminé.
• Remarque: notez bien les indentations du code, c’est obligatoire pour la lisibilité de vos
programmes.

Exercice : Ecrire un programme qui permet de lire deux entiers A et B et d’afficher le résultat de la
comparaison de A et de B.
void main( ) {
int A,B ;
printf("Donnez deux entiers :") ;
scanf("%d %d",&A,&B) ;
if (A>B)
printf("%d > %d", A, B);
else
if (A<B)
printf("%d < %d", A, B);
else
printf("%d = %d", A, B);
}

4. Les opérateurs conditionnels

• Syntaxe :
<expression 1> ? <expression 2> : <expression 3>;

Si expression 1 fournit une valeur différente de 0 alors la valeur de expression 2 est

o
fournie comme résultat sinon expression 3.
• Exemple :
if (A>B)
max = A ;

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 4/13

else
max = B;

Ces lignes sont équivalentes à cette ligne :

max = (A>B)? A : B ;

5. Les tests multiples (switch)

Lorsque les alternatives sont plus nombreuses, on peut utiliser la commande switch qui désigne la
valeur à étudier, suivie des instructions à exécuter en fonction des divers cas (commande case). Plus
précisément, l’exécution des commandes commence lorsque la valeur étudiée apparaît, jusqu’à la fin
(ou jusqu’au break). Si la valeur n’apparaît jamais, le cas default englobe toutes les valeurs :

• Syntaxe :
Switch (<expression>)
{
case constante_1 : <instructions 1> ;
case constante_2 : <instructions 2> ; break ;
……………
case constante_N : <instructions N> ; break ;
default : <instructions N+1> ; break ;
}

o Le mot clé switch doit être suivi d’une expression fournissant un résultat par
exemple : le nom d’une variable ou une expression arithmétique.
o Les instructions correspondant au cas default sont exécutées lorsqu’aucun des cas
n’est vérifié.
o Remarque : expression ne peut pas être de type chaine de caractères

• Exemple
int a = 6 ;
switch (a) {

case 2: printf ("la variable vaut 2"); break;

case 4: printf ("la variable vaut 4"); break;

case 6: printf ("la variable vaut 6"); break;

default: printf("ni 2, ni 4, ni 6");

}
• Exemple :
char c = 'A';
switch (c){
case 'A':
printf("lettre A\n");
break;
case 'B':
printf("lettre B\n");
break;
}

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 5/13

L'étiquette représentée par le mot-clef default n'est associée à aucune constante

o
particulière et permet de fournir les instructions à exécuter si aucune autre étiquette
ne correspond à la valeur évaluée ; elle est optionnelle, et en cas d'absence le corps
du switch n'exécutera aucune instruction
o Ces instructions peuvent être terminées par l'instruction de contrôle break
 Elle n'est pas strictement obligatoire
 En effet, sans cette instruction l'exécution du code se poursuit avec les
instructions de l'étiquette suivante !
• Exemple: Exécutons ce programme:

#include <stdio.h>
void main()
{
int a = 1;
switch (a) {
case 1: printf("bonjour 1 !!!\n");
case 2: printf("bonjour 2 !!!\n"); break;
case 4: printf("bonjour 4 !!!\n"); break;
default: printf("ni 1, ni 2 ni 4!!!\n");
}
}

L’exécution pour a = 9 donne : ni 1, ni 2 ni 4

L’exécution pour a = 1 donne :

bonjour 1 !!!
bonjour 2 !!!

L’exécution pour a = 2 donne : bonjour 2 !!!

L’exécution pour a = 4, bonjour 4 !!!

II. Les structures répétitives

Les structures répétitives (les boucles) permettent de répéter une série d’instructions sous une
certaine condition. Dans ce chapitre on va étudier la syntaxe de ces structures et faire des exercices
en utilisant cette syntaxe.

1. La boucle while
Syntaxe :
while (<expression>)
{
<Bloc d’instructions> ;
}

• Tant que expression fournit une valeur différente de zéro, le bloc d’instructions sera exécuté
sinon l’exécution continue avec l’instruction qui suit le bloc d’instruction: la condition de
poursuite de la boucle est examinée avant chaque parcours de la boucle et non après.
• Le bloc d’instructions est exécuté zéro ou plusieurs fois.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 6/13

• La partie expression peut désigner

o Une variable de type numérique
o Une expression fournissant un résultat numérique
• La partie bloc d’instructions peut désigner:
o Un bloc d’instructions compris entre accolades
o Une seule instruction terminée par un point-virgule
• ATTENTION ! Si rien ne vient modifier l’expression dans les instructions, on a alors fait
une boucle infinie:
o while (1) { instructions ; } en est un exemple.

Exemple 1:
Ecrire un programme qui permet d’afficher les nombres compris entre 0 et 9 séparés par une
tabulation.

#include <stdio.h>
void main()
{
int i = 0;
while (i<10)
{
printf("%d\t ",i) ;
i = i+1;
}
}

Exercice 1:
Ecrire un programme qui permet de lire un entier n et de calculer la somme des n premiers entiers.

#include <stdio.h>
void main()
{
int i, s, n ;
printf("donnez un entier ");
scanf("%d ",&n) ;
i=1; s=0;
while (i <=n)
{
s = s+i; /*ou bien s += i ;*/
i = i+1;
}
printf("la somme des %d premiers entiers est %d ", n, s) ;
}

Exercice 2 :
Ecrire un programme qui affiche les diviseurs de n, un entier tapé au clavier:

#include <stdio.h>
void main()
{
int i, n ;
printf("donnez un entier ");
scanf("%d ",&n) ;
i=1;

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 7/13

while (i <= n)
{
if (n % i == 0)
printf("diviseur de %d: %d\n", n, i);
i = i+1;
}
}

2. La boucle do…while

Syntaxe:
do
{
<bloc d’instructions> ;
} while(<expression>);
• La boucle do…while teste sa condition après l’exécution du bloc d’instructions.
• Le bloc d’instructions est exécuté au moins une fois quelque soit le résultat de
l’expression.
• Une application typique de do…while est la saisie de données qui doivent vérifier une
certaine condition.

Exemple:
int N ;
do
{
printf("donnez un nombre entre 1 et 10 sauf 1 et 10: ") ;
scanf("%d", &N) ;
} while (N<=1 || N>=10);
printf("nombre saisi satisfaisant, sortie de la boucle") ;

Après exécution :
donnez un nombre 1 et 10: 1
donnez un nombre 1 et 10: 88
donnez un nombre 1 et 10: 99
donnez un nombre 1 et 10: 6
nombre saisi satisfaisant, sortie de la boucle

3. La boucle for
Syntaxe :

for (expression_I ; expression_C ; expression_R)

{
<Bloc d’instructions>
}
o expression_I : expression qui initialise les variables de contrôle avant d’entrer dans la
boucle (ça peut être plus qu’une variable).
o expression_C : la condition de bouclage

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 8/13

o expression_R : expression permettant d’incrémenter ou décrémenter les variables de

contrôle utilisées.
La boucle for est équivalente à :

<expression_I >;
while (<expression_C>)
{
<bloc d’instructions>;
<expression_R>;
}

o Déroulement de la boucle for :

1. Exécuter les instructions d’initialisation (expression_I)
2. Evaluer la condition de bouclage (expression_C)
 Si c’est faux : aller à l’instruction qui suit la fin du bloc for.
 Si c’est vrai :
• Exécuter le bloc d’instructions ;
• Exécuter le bloc expression d’incrémentation (expression_R)
• Revenir à 2.

Exemple 1:
Ecrire un programme qui permet de calculer et afficher le carré des entiers entre 0 et 5
int i ;
for (i=0 ; i<= 5 ;i++)
printf("le carré de %d est %d \n", i, i*i) ;

 Résultat de l’exécution :

Pour i = 0 -> le carré de 0 est 0.

i = 1 ->le carré de 1 est 1.
i = 2 -> le carré de 2 est 4.
i = 3 -> le carré de 3 est 9.
i = 4 -> le carré de 4 est 16.
i = 5 -> le carré de 5 est 25.
i = 6 -> sortie de la boucle, la fonction printf n’est pas
exécutée

Exemple 2:
Ecrire un programme pour le calcul de la somme des entiers de 1 à 100 en utilisant la boucle for:

int s = 0;
int i;
for (i=1; i<=100 ; i++)
s += i;
printf ("la somme de 1 à 100 = %d\n", s);

On peut aussi écrire:

int i, s = 0;
for (i=1; i<=100 ;s+=i, i++);
printf ("(en sortant de la boucle, i=%d), la somme de 1 à 100 =
%d\n", i, s);

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 9/13

//-> ça donne : (en sortant de la boucle, i=101), la somme de 1 à

100 = 5050

Ou bien
int i=1, s=0;
for ( ; i<=100; s+=i, i++);
printf("i=%d, la somme de 1 à 100 = %d\n",s) ;
//-> ça donne : i=101, la somme de 1 à 100 = 5050

Exemple 3:
Ecrire un programme qui affichage des diviseurs d’un entier n donné au clavier en utilisant la
boucle for:

int n ;
printf("Donner un nombre : \n");
scanf("%d",&n);
for (i=1; i<= n; i++)
if (n% i == 0)
printf("diviseur %d",i);

Remarque :

Les blocs suivants sont équivalents :

1. for (i=0, j=9, k=5; … ; …)
2. int j=9 ; int k=5 ;
for (i=0 ; … ; …)

Remarque: Quelle structure répétitive choisir ?

• Si le bloc d'instructions ne doit pas être exécuté si la condition est fausse, alors utilisez
while ou for.
• Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez do - while.
• Le choix entre for et while n'est souvent qu'une question de préférence ou d'habitudes.

Figure 1 Organigramme de la boucle : for (exp1; exp2; exp3)

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 10/13

Figure 2 Organigramme de la boucle while

Figure 3 Organigramme de la boucle do while

4. Les boucles imbriquées

Nous pouvons imbriquer plusieurs boucles.
Exemple :

int i,j ;
for (i=1;i<10;i++)
{
for (j=1;j<10;j++)
{
printf("%3d",i*j);
}
printf("\n");
}
Ce programme affiche:

o La boucle sur « j » est appelée boucle interne. Elle affiche le produit « i*j » sur une
ligne.
o La boucle sur « i » est appelée boucle externe. Elle affiche donc une ligne (boucle sur
j) puis effectue un saut de ligne.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 11/13

o On peut donc imbriquer autant de boucles (« for », « while », « do ») que l'on veut.

III. Les instructions de branchement inconditionnel : continue,

break, goto
Ces instructions fournissent des possibilités diverses de branchement inconditionnel. Break et
continue s’utilisent principalement au sein des boucles. L’instruction goto s’utilise n’importe où dans
le programme mais très peu répandu.

1. Branchement inconditionnel break

• On a vu le rôle de l’instruction break au sein d’une instruction de branchement multiple
switch.
• L’instruction break peut, plus généralement, être employée à l’intérieur de n’importe
quelle boucle.
• Elle permet d’interrompre le déroulement de la boucle, et passe à la première
instruction qui suit la boucle.
• En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.
• Exemple : Essayez de deviner le résultat d’exécution de ce programme.

main()
{
int i;
for (i = 0; i < 5; i++)
{
printf("i = %d\n",i);
if (i == 3)
break;
}
printf("valeur de i à la sortie de la boucle = %d\n",i);
}
Imprime à l’écran :
i = 0
i = 1
i = 2
i = 3
valeur de i à la sortie de la boucle = 3

2. Branchement inconditionnel continue

• L’instruction continue permet de passer directement à l’itération suivante de la

boucle, sans exécuter les autres instructions de la boucle.
• Exemple : Essayez de deviner le résultat d’exécution de ce programme.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020

Page - 12/13

main() {
int i;
for (i = 0; i < 5; i++)
{
if (i == 3)
continue;
printf("i = %d\n",i);
}
printf("valeur de i à la sortie de la boucle = %d\n",i);
}

Imprime :
i = 0
i = 1
i = 2
i = 4
valeur de i à la sortie de la boucle = 5

3. Branchement non conditionnel goto

L’instruction goto permet d’effectuer un saut jusqu’à l’instruction etiquette correspondante.

Elle est à proscrire de tout programme C digne de ce nom.

Exemple : Essayez de deviner le résultat d’exécution de ce programme.

main()
{
int i;
for (i = 1; i < 10; i++)
{
printf("début tour %d\n",i);
printf("bonjour\n");
if (i == 3)
goto sortie;
printf("fin tour %d\n",i);
}
sortie: printf("après la boucle \n");
}
Imprime à l’écran :

début tour 1
bonjour
fin tour 1
début tour 2
bonjour
fin tour 2
début tour 3
bonjour
après la boucle

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2019-2020