Chapitre 4 - GII - GT

1 GII / GT
Algorithmique & programmation

en langage C
Chapitre 4 Les structures de

contrôle
Les structures conditionnelles
Les structures itératives
Les ruptures de séquences
Dr. -Ing Mouna Medhioub

Chapitre 4 Les structures de contrôle
L’instruction if… else

• L'instruction « if » sélectionne le traitement à faire si une condition est vérifiée. Lorsque « if » est
utilisée avec « else », elle indique le traitement à faire si la condition n'est pas vérifiée.
Algorithmique Langage C
Si (condition) alors if (condition)
{
Bloc 1 Bloc 1 ; /* bloc 1 d'instructions */
sinon }
else
Bloc 2 {
FinSi Bloc 2 ; /* bloc 2 d'instructions */
}
→ Si la condition évaluée est vraie, le C réalise la ou les instructions contenues dans <Bloc1>.
→ Si non, il réalise la ou les instructions contenues dans la partie <Bloc2>.
On rappelle que: valeur = 0 -> FAUX et toute valeur ≠ 0 -> VRAI
• La partie « else » est facultative.
• Les {} ne sont pas nécessaires lorsque les blocs ne comportent qu'une seule instruction.
Dr. -Ing Mouna Medhioub 2

• La partie « else » est toujours liée au dernier « if » qui ne possède pas de partie « else ».
• Pour forcer une exécution, il faut utiliser les accolades.
if(N>0) if(N>0)
{
Exemple if(A>B) if(A>B)
MAX=A; MAX=A;
}
else MAX=B; else MAX=B;
Exercice
if (i < 10) i++; La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.
if (i == 10) i++; La variable i ne sera incrémentée que si elle est égale à 10.
if (!recu) printf ("rien reçu\n"); Le message "rien reçu" est affiché si recu vaut zéro.
if ((!recu) && (i < 10)) i++; i ne sera incrémentée que si recu vaut zéro et i<10.

Exercice
Ecrire un programme qui permet de tester si les deux caractères A et B, saisis au clavier, sont
différents ou non avec l’affichage du résulta.
#include < stdio.h >

int main()
{
char A, B;
scanf("%c %c", &A, &B);
if (A - B)
printf("A est différent de B\n");
else
printf("A egale à B\n");
return 0;
}

if… else Imbriquées

Il est possible d'imbriquer plusieurs structures « if…else », cela permet de prendre des
décisions entre plusieurs alternatives.
if (expression 1)
{
Bloc 1 ; /* bloc 1 d'instructions */
}
else if (expression 2)
{
}
else
{
}

Exercice
Ecrire un programme qui permet de comparer deux nombres entiers i et j saisie au clavier.
Méthode 1 Méthode 2
#include < stdio.h > #include < stdio.h >
int main() int main()
{ {
int i, j;
int i, j; scanf("%d %d", &i, &j);
scanf("%d %d", &i, &j); if (i < j) printf("%d est plus petit que %d \n", i, j);
if (i < j) printf("%d est plus petit que %d \n", i, j); else
else if (i > j) printf("%d est plus grand que %d \n", i, j); {
else printf("%d est egal a %d \n", i, j); if (i > j) printf("%d est plus grand que %d \n", i, j);
else printf("%d est egal a %d \n", i, j);
return 0; }
} return 0;
}

L’opérateur conditionnel « ? »
• L’opérateur conditionnel est un opérateur particulier dont le résultat dépend de la
réalisation d’une condition.
• L’opérateur conditionnel « ? » est équivalent à l’instruction « if…else ».
• Son avantage est qu’il peut être intégré dans une expression.
result = condition ? expr1 : expr2 ; ✓ si condition est vraie → result=expr1

✓ sinon, → result=expr2
/*L’opérateur conditionnel « ? »
#include <stdio.h>
int main(void)
Exemple { int heure;
scanf("%d", &heure);
(heure > 8 && heure < 20) ? printf("Il fait jour.\n") : printf("Il fait nuit.\n"); return 0; }

Exercice
Ecrire un programme qui recherche le maximum des deux nombres entiers a et b saisie au
clavier en utilisant l’opérateur conditionnel « ? ».
Avec if….else
#include < stdio.h > #include < stdio.h >
int main() int main()
{ { int a, b, Max;
int a, b, Max; scanf("%d %d", &a, &b);
scanf("%d %d", &a, &b); if (b>=a)
Max = a > b ? a : b; printf("%d est le maximum \n", b);
printf("%d est le maximum \n", Max); else
return 0; printf("%d est le maximum \n", a);
} return 0; }

L’instruction switch
• Le « switch » est une "table de branchement" qui permet d'éviter les imbrications de
« if ».
switch (variable de contrôle)
{
case valeur_a:
Instruction 1a; /* Liste d’instruction 1 */
…………………...;
break;
case valeur_b:
instruction 1b;
/* Liste d’instruction 2 */
......................;
break;
………………..... /* Autre « case » */
default : liste d'instructions;
}

• L’instruction « switch » reçoit entre parenthèses la variable à tester (variable de contrôle).
• La variable de contrôle est évaluée et comparée aux valeurs des expressions constantes:
✓ Si sa valeur apparaît dans une étiquette « case », le contrôle du programme
est transféré à cette étiquette.
✓ Sinon il est transféré à l'étiquette « default » (si elle existe).
• Il est possible de définir un cas par défaut « default », c'est-à-dire de préciser un
comportement si la variable ne correspond à aucune des valeurs spécifiées dans les
« case ».
• L’instruction « default » est facultative.
• L'instruction « switch » est souvent utilisée avec l'instruction « break » afin d'exécuter
seulement les instructions spécifiques à l’étiquette sélectionnée.
• L'exécution se poursuit jusqu'à la fin du switch, à moins qu'une instruction rupture de
séquence (« break », « return », « continue », « goto ») ne soit rencontrée.

Exemple
int a ; scanf("%d", &a);
switch (a) {
case 0: printf("Le nombre introduit est zéro\n"); break; /* le programme traite tous les
case 1: printf("Le nombre introduit est 1\n"); cas de a (0,1 ou autres) */
break;
default:
printf("Le nombre introduit est différent de 0 et 1\n"); }
Exemple
char c ; scanf("%c", &c);
switch (c)
{
/* le programme traite uniquement
case 'x': printf("La lettre saisie est la lettre x\n");
les cas où c égale à 'x' ou 'y'*/
break;
case 'y':
printf("La lettre saisie est la lettre y\n");
break; }

• On peut faire le traitement soit le même si Var a la valeur_b ou la valeur_c, mais on veut
aussi un traitement spécifique pour la valeur_a :
switch (Var)
{
case valeur_a:
Instruction 1a;
…………………...;
break;
case valeur_b :
case valeur_c:
Instruction 1bc;
…………………...;
break;
}

Exercice
Ecrire un programme, en utilisant l’instruction switch qui lire un entier entre 1 et 7 et d’afficher le
jour de la semaine correspondant et dans le cas où la valeur entrée ne se trouve pas dans
l’intervalle [1,7], un message « Erreur Num !!!» sera affiché. Indication: 1: lundi,…..,7: dimanche.
#include <stdio.h>
int main()
{ int Num;
printf("Entrez un entier : ");
scanf("%i", &Num);
switch (Num) {
case 1: printf("Lundi");break;
case 2: printf("Mardi"); break;
case 3: printf("Mercredi"); break;
case 4: printf("Jeudi"); break;
case 5: printf("Vendredi"); break;
case 6: printf("Samedi"); break;
case 7: printf("Dimanche");break;
default: printf("Error Num !!!"); }
return 0; }

La boucle for
• L'instruction « for » permet de répéter un traitement donné un nombre de fois précis.
pour v de vi à vf faire for (Initialisation ; Condition ; Modification)
{
bloc d'instructions
Traitement ; /* est un bloc d'instructions qui se terminent par ; */
finpour
}
✓ L'initialisation d'une variable de contrôle, elle est évaluée une seule fois au début de la boucle.
✓ La condition de continuation de la boucle, elle est évaluée au début de chaque itération.
✓ Modification : l'incrémentation/ décrémentation de la variable de contrôle et elle est effectuée

après l'exécution du bloc d'instructions.

Exemple Exemple
#include <stdio.h> 1 x=0 #include <stdio.h> 2 x=4
void main() x=1 void main() x=3
{ int x; x=2 { int i; x=2
for (x = 0;x < 5;x++) x=3 for (i = 4;i >= 0;i--) x=1
{ printf("x=%d\n", x); } 1 x=4 { printf("x=%d\n", i); } 2 x=0
} }
• Il est possible d’initialiser/modifier plusieurs variables de boucle en même temps en utilisant

des virgules dans les expressions :
Exemple
#include <stdio.h>
3 La somme des nombres = 5050
void main()
{ int n, t, s = 10; 4 -90
for (t = 0, n = 1;n < 101;n++, --s)
t += n;
printf("La somme des nombres = %d\n", t); 3
printf("%d\n", s); } 4

• Les 3 expressions du « for » ne portent pas forcément sur la même variable.
Utilisation d’une même variable Utilisation des variables différentes

Exemple Exemple
#include <stdio.h> #include <stdio.h>
void main() void main()
{ { int i, resultat = 0;
for (int i = 0; i < 5; i++) for (i = 0; resultat < 30; i++)
{ { resultat = resultat + 2 * i;
printf("Le carree de % d est % d\n", i, i * i); } 1 printf("%d\n", resultat); } 2
} }
Le carree de 0 est 0 2 0
1
Le carree de 1 est 1 2
30

La boucle while
• L'instruction « while » permet de répéter un traitement autant de fois qu'une condition est
vérifiée.
tant que (condition) faire while (condition)
{
bloc d'instructions
Traitement ; /* est un bloc d'instructions qui se terminent par ; */
fintantque
}
• Lors de l'utilisation de l'instruction « while », à chaque itération, la condition est évaluée

en premier, avant l'exécution du traitement.
→ Tant que la condition est vérifiée (ou non nulle), le bloc d’instruction est exécuté.
• Notez l’absence de point-virgule (;) après la condition.

• S'il n'y a qu'une seule instruction, les accolades sont inutiles.

• Si la condition est fausse dès le début, le bloc n’est même pas exécuté une seule fois.
Exemple Exemple Exemple

#include <stdio.h> #include <stdio.h> #include <stdio.h>
main() main() main()
{ int x = 0; { {
while (x < 5) int x = 0; int x = 5;
{ while (x < 5) while (x < 5)
printf("x=%d\n", x); 1 printf("x=%d\n", x++); 2 printf("x=%d\n", x++); 3
x++; } } }
}
1 x=0 2 x=0
x=1 x=1 Rien affiché
x=2 x=2
x=3 x=3
x=4 x=4

La boucle do…while
• L'instruction « do…while » permet de répéter un traitement jusqu'à ce qu'une condition
ne soit plus vérifiée.
répéter do
{
bloc d'instructions instruction 1;
... /* bloc d'instructions */
jusqu’à (condition)
instruction n;
}
while(condition) ;
• Fonctionnement: le bloc d’instructions est exécuté en premier, puis la condition est testée.
→ L'instruction « do…while » permet de répéter un traitement jusqu'à ce qu'une
condition ne soit plus vérifiée.

• La condition est exprimée sous la forme d’une expression entre parenthèses, placée après
un « while ».
→ Le test se faisant après, le bloc est exécuté au moins une fois même si l'expression est nulle
à la première évaluation.
• La différence ici, est que le « while » est placé après le bloc, et qu’elle est suivie d’un point-
virgule (;).
• Il est nécessaire d’initialiser manuellement la variable de boucle avant le « do ».
Exemple
#include <stdio.h>
main() 1 x=0
{ int x; x = 0; x=1
do x=2
{ printf("x=%d\n", x); 1 x=3
x = x + 1; } x=4
while (x < 5); }

Exercice
Exercice
Réécrire le programme (a) en réalisant exactement la même chose, en employant, à la place de
l’instruction « for » : l’instruction « while » dans le programme (b) et par l’instruction « do...while »
dans le programme (c) .
programme (a) programme (b) programme (c)
#include <stdio.h> #include <stdio.h> #include <stdio.h>
main() main() main()
{ int i, n, som; { int i, n, som; {int i = 0, n, som = 0;
som = 0; som = 0, i = 0; do
for (i = 0; i < 4; i++) while (i < 4) { printf("donnez un entier ");
{ { printf("donnez un entier "); scanf("%d", &n);
printf("donnez un entier ");
scanf("%d", &n); som += n;
scanf("%d", &n);
som += n; i++;
som += n; }
printf("Somme : %d\n", som); i++; } } while (i < 4);
} printf("Somme : %d\n", som); printf("Somme : %d\n", som);
} }

• Dans le cas où une boucle commande l'exécution d'un bloc d'instructions, il peut être
intéressant de vouloir sortir de cette boucle alors que la condition de passage est encore
valide.
→ Ce type d'opération est appelé une rupture de séquence.

• Les ruptures de séquence sont utilisées lorsque des conditions multiples peuvent
conditionner l'exécution d'un ensemble d'instructions.
• Les ruptures de séquence peuvent être réalisées par ces trois instructions:
✓ « break »
✓ « continue »
✓ « goto »

« break »
• Nous avons déjà vu l’utilisation du break dans le « switch ».
break ;
/*l’instruction « break »
• L'instruction « break » peut, plus généralement, être employée à l'intérieur de

n'importe quelle boucle.
• « break » permet de sortir directement de la boucle (« for », « while » ou « do…while »)

la plus interne.
→ 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
#include <stdio.h>
main() i=0
{ int i; i=1
for (i = 0; i < 5; i++) i=2
{ if (i == 3) valeur de i a la sortie de la boucle = 3
break;
printf("i = %d\n", i); }
printf("valeur de i a la sortie de la boucle = %d\n", i); }
Exemple
#include <stdio.h>
main() valeur de i a la sortie de la boucle = 0
{ int i;
for (i = 0; i < 5; i++)
{ if (i == 3)
printf("i = %d\n", i);
break; }

Exemple
#include <stdio.h> /* Il arrive fréquemment qu’on désire que seules
main() les instructions placées directement en dessous
{ du case correspondant soient exécutées, mais
int x;
scanf("%d",&x);
pas les suivantes. Pour arriver à ce
switch (x) comportement, il faut ajouter l’instruction
{ « break » juste avant le case suivant */
case 1: printf("un\n"); break;
case 2: printf("deux\n"); break;
case 3: printf("trois\n"); break;
default: printf("autre\n");
}
}

« continue »
• L'instruction « continue » permet de passer directement au tour de boucle suivant, sans
exécuter les autres instructions de la boucle.
→ Il provoque la non-exécution des instructions qui le suivent à l'intérieur du bloc.
→ « continue » permet de passer directement à l'itération suivante de la boucle la plus
interne.
Exemple
#include<stdio.h> i=0
main() i=1
{ int i; i=2
for (i = 0; i < 5; i++) i=4
{ if (i == 3) valeur de i a la sortie de la boucle = 5
continue;
printf("i = %d\n", i); }

Exemple
Exemple
#include<stdio.h>
main() #include <stdio.h>
{ int i = 2; int main()
do { int i = 5, j = 0, x = 1;
{ i++; while ((i--) > 0)
if (i == 5) { x += 1;
continue; if (x % 2)
printf("i = %d\n", i); continue;
} while (i < 7); j += x * x; }
} printf("j = %d\n", j); }
i=3
j = 56
i=4
i=6
i=7

« goto »
• L'instruction « goto » permet d'effectuer un saut jusqu'à l'instruction étiquette appelée
« label » correspondant.
✓ Etiquette appelée label.
goto Etiquette ;
/*l’instruction aller à (goto) ✓ Un label est une chaîne de caractères suivie de :
• Fonctionnement : le système interrompt l'exécution séquentielle du programme, remonter ou
descendre à la ligne appelée étiquette et poursuit l'exécution à partir de celle-ci.
Exemple Exemple
main() main()
{ {
goto stop; /* goto avant la définition de l'étiquette stop */ start :
... /* instructions */ ... /* instructions */
stop : goto start; /* goto après la définition de l'étiquette start */
... /* instructions */ … /* instructions */
} }

• Il est cependant très utilisé après des détections d'erreur, car il permet de sortir de
plusieurs blocs imbriqués.
Exemple
#include <stdio.h>
int main()
{ int nombre;
debut: // debut est une étiquette
printf("Entrez un nombre entre 1 et 3 : ");
scanf("%d", &nombre);
if (nombre < 1 || nombre > 3) // Si le nombre n'est pas compris entre 1 et 3
goto debut; // On saute à l'étiquette debut
printf("\nBravo ! Tu as entre un nombre entre 1 et 3 !");
return 0; }

Chapitre 4 - GII - GT

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 4 - GII - GT

Transféré par

Droits d'auteur :

Formats disponibles

1 GII / GT

Algorithmique & programmation

Chapitre 4 Les structures de

Dr. -Ing Mouna Medhioub

L’instruction if… else

Dr. -Ing Mouna Medhioub 2

Dr. -Ing Mouna Medhioub 3

#include < stdio.h >

Dr. -Ing Mouna Medhioub 4

if… else Imbriquées

Dr. -Ing Mouna Medhioub 5

Dr. -Ing Mouna Medhioub 6

result = condition ? expr1 : expr2 ; ✓ si condition est vraie → result=expr1

Dr. -Ing Mouna Medhioub 7

Dr. -Ing Mouna Medhioub 8

Dr. -Ing Mouna Medhioub 9

• L’instruction « switch » reçoit entre parenthèses la variable à tester (variable de contrôle).

Dr. -Ing Mouna Medhioub 10

Dr. -Ing Mouna Medhioub 11

Dr. -Ing Mouna Medhioub 12

Dr. -Ing Mouna Medhioub 13

✓ La condition de continuation de la boucle, elle est évaluée au début de chaque itération.

✓ Modification : l'incrémentation/ décrémentation de la variable de contrôle et elle est effectuée

Dr. -Ing Mouna Medhioub 14

• Il est possible d’initialiser/modifier plusieurs variables de boucle en même temps en utilisant

Dr. -Ing Mouna Medhioub 15

• Les 3 expressions du « for » ne portent pas forcément sur la même variable.

Utilisation d’une même variable Utilisation des variables différentes

Dr. -Ing Mouna Medhioub 16

• Lors de l'utilisation de l'instruction « while », à chaque itération, la condition est évaluée

Dr. -Ing Mouna Medhioub 17

• S'il n'y a qu'une seule instruction, les accolades sont inutiles.

Exemple Exemple Exemple

Dr. -Ing Mouna Medhioub 18

Dr. -Ing Mouna Medhioub 19

Dr. -Ing Mouna Medhioub 20

Dr. -Ing Mouna Medhioub 21

→ Ce type d'opération est appelé une rupture de séquence.

Dr. -Ing Mouna Medhioub 22

• L'instruction « break » peut, plus généralement, être employée à l'intérieur de

• « break » permet de sortir directement de la boucle (« for », « while » ou « do…while »)

→ Elle permet d'interrompre le déroulement de la boucle, et passe à la première

• En cas de boucles imbriquées, « break » fait sortir de la boucle la plus interne.

Dr. -Ing Mouna Medhioub 23

Dr. -Ing Mouna Medhioub 24

Dr. -Ing Mouna Medhioub 25

Dr. -Ing Mouna Medhioub 26

Dr. -Ing Mouna Medhioub 27

Dr. -Ing Mouna Medhioub 28

Dr. -Ing Mouna Medhioub 29

Vous aimerez peut-être aussi