Chap02 CondtionsBoucles

Les structures alternatives
LEs structures répetitives

Les instructions de branchement non conditionnel
Les structures altérnatives et

répétitives en C
Pr Mostafa SAADI – ENSAK
L’Ecole Nationale des Sciences Appliquées à Khouribga

saadi mo@yahoo.fr
2 octobre 2019
1/67
Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
Plan du Cours
1 Les structures alternatives
2 LEs structures répetitives

LA BOUCLE TANT QUE ... FAIRE ...
L’INSTRUCTION REPETER ... TANT QUE ...
L’INSTRUCTION POUR ...
Choix de la structure répétitive
3 Les instructions de branchement non conditionnel
2/67
L’INSTRUCTION SI ... ALORS ... SINON ...
Les structures alternatives L’INSTRUCTION SI ... ALORS ... SINON SI ...
LEs structures répetitives LES OPERATEURS LOGIQUES
Les instructions de branchement non conditionnel Les opérateurs conditionnels
L’INSTRUCTION AU CAS OU ... FAIRE ...
Introduction
Introduction
Les structures de contrôle définissent la suite dans laquelle
les instructions sont effectuées. Dans ce chapitre, nous allons
voir comment les instructions de sélection connues fonctionnent en
C et nous allons faire connaissance d’un couple d’opérateurs
spécial qui nous permet de choisir entre deux valeurs à l’intérieur
d’une expression.
C
onstatons déjà que la particularité la plus importante des
instructions de contrôle en C est le fait que les ’conditions’ en C
peuvent être des expressions quelconques qui fournissent un
résultat numérique. La valeur zéro correspond à la valeur logique
faux et toute valeur différente de zéro est considérée comme 3/67
vrai. Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
Outline

L’INSTRUCTION SI ... ALORS ... SINON SI ...
LES OPERATEURS LOGIQUES
Les opérateurs conditionnels
4/67
L’instruction SI
Il s’agit de l’instruction :
si (expression conditionnelle vraie)
alors BLOC 1 D’INSTRUCTIONS
sinon BLOC 2 D’INSTRUCTIONS
Organigramme
5/67
L’instruction SI
Syntaxe en C :
if (expression)
{
............; /* bloc 1 d'instructions */
............;
............;
}
else
{
............; /* bloc 2 d'instructions */
............;
............;
} 6/67
L’instruction SI
Le bloc ”sinon” est optionnel :

si (expression vraie) alors BLOC D’INSTRUCTIONS
Syntaxe en C :
if (expression)
{
............; /* bloc d'instructions */
............;
............;
}
Remarque :
les {} ne sont pas nécessaires lorsque les blocs ne comportent 7/67
Outline

8/67
L’instruction SI ... ALORS ... SINON SI ...

SI en cascades
En combinant plusieurs structures if - else en une expression nous
obtenons une structure qui est très courante pour prendre des
décisions entre plusieurs alternatives : if - else - ... - else
if ( <expr1> )
<bloc1>
else if (<expr2>)
<bloc2>
else if (<expr3>)
<bloc3>
else if (<exprN>)
<blocN> 9/67
else <blocN+1>
Les expressions < expr 1 > ... < exprN > sont évaluées du
haut vers le bas jusqu’à ce que l’une d’elles soit différente de
zéro. Le bloc d’instructions y lié est alors exécuté et le
traitement de la commande est terminé.
La dernière partie else traite le cas où aucune des conditions
n’a été remplie. Elle est optionnelle, mais elle peut être utilisée
très confortablement pour détecter des erreurs.
10/67

Exemple
#include<stdio.h>
main()
{
int A,B;
printf("Entrez deux nombres entiers :");
scanf("%i %i", &A, &B);
if (A > B)
printf("%i est plus grand que %i\n", A, B);
else if (A < B)
printf("%i est plus petit que %i\n", A, B);
else
printf("%i est égal à %i\n", A, B); 11/67
return 0; Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
Outline

12/67
Les opérateurs logiques

test d’égalité :
if (a==b) " si a égal b "
test de non égalité :
if (a!=b) " si a différent de b "
tests de relation d’ordre :
if (a<b) if (a<=b) if (a>b) if (a>=b) 13/67

test de ET LOGIQUE :
if ((expression1) && (expression2))

" si l'expression1 ET l'expression2 sont vraies "
test de OU LOGIQUE
if ((expression1) || (expression2))
" si l'expression1 OU l'expression2 est vraie "
14/67
test de NON LOGIQUE
if (!(expression1))
" si l'expression1 est fausse "
Toutes les combinaisons sont possibles entre ces tests.
15/67
Le langage C admet des écritures contractées dans les expressions

de test :
char reponse; char reponse;

printf("Voulez-vous printf("Voulez-vous
continuer ?"); continuer ?");
reponse = getchar();
if(reponse == 'o') if((reponse = getchar()) ==
printf("BONJOUR\n"); 'o')
else printf("TANT-PIS"\n); printf("BONJOUR\n");
else printf("TANT-PIS"\n);
16/67
Outline

17/67
Le langage C possède une paire d’opérateurs ( : et ?) un peu

exotiques qui peut être utilisée comme alternative à if - else et qui
a l’avantage de pouvoir être intégrée dans une expression.
<expr1> ? <expr2> : <expr3>
Si < expr 1 > fournit une valeur différente de zéro, alors la

valeur de < expr 2 > est fournie comme résultat
Si < expr 1 > fournit la valeur zéro, alors la valeur de
< expr 3 > est fournie comme résultat
18/67
Exemple
La suite d’instructions
if (A>B)
MAX=A;
else
MAX=B;
peut être remplacée par :
MAX = (A > B) ? A : B;
19/67
Conseil
Employés de façon irréfléchis, les opérateurs conditionnels peuvent
nuire à la lisibilité d’un programme, mais si on les utilise avec
précaution, ils fournissent des solutions très élégantes.
Exemple
printf("Vous avez %i carte%c \n", N, (N==1|| N==0) ?

' ' : 's');
20/67
Outline

21/67
switch ... case
L’instruction switch permet des choix multiples uniquement sur

des entiers (int) ou des caractères (char).
L’instruction switch correspond à une cascade d’instructions if

...else
22/67
switch ... case

Syntaxe :
switch(variable de type char ou int)//au cas où la

variable vaut:
{
case valeur1: ......;// cette valeur1: executer ce
bloc d'instructions.
.......;
break;
valeur2:........;// cette valeur2: executer ce
bloc d'instructions.
........;
break;
. 23/67
. Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
switch ... case
Syntaxe suite :
.
. etc ...
.
default: .......; //- aucune des valeurs
précédentes: executer ce bloc
........; // d'instructions, pas de "break"
ici.
}
24/67
switch ... case
Remarques
le bloc ”default” n’est pas obligatoire.
s’il existe un énoncé case avec une constante qui égale la
valeur de expression, le contrôle est transféré à l’instruction
qui suit cet énoncé.
si un tel case n’existe pas, et si l’énoncé default existe, alors le
contrôle est transféré à l’instruction qui suit l’énoncé default ;
si la valeur de expression ne correspond à aucun case et s’il
n’y a pas d’énoncé default, alors aucune instruction n’est
exécutée.
Cette instruction est commode pour fabriquer des ”menus”.
25/67
switch ... case
Remarques
Lorsqu’il y a branchement réussi à un énoncé case, toutes les
instructions qui le suivent sont exécutées, jusqu’à la fin du
bloc ou jusqu’à une instruction de rupture (break).
26/67
switch ... case

Exemple :
char choix;
printf("LISTE PAR GROUPE TAPER 1\n");
printf("LISTE ALPHABETIQUE TAPER 2\n");
printf("POUR SORTIR TAPER S\n");
printf("\nVOTRE CHOIX: ");
choix = getchar();
switch(choix)
{
case '1': .......;
.......;
break;
27/67
switch ... case
Exemple :
case '2': ......;

......;
break;
case 'S': printf("\nFIN DU PROGRAMME ....");

break;
default; printf("\nCE CHOIX N'EST PAS PREVU "); /*

pas de break ici */
}
28/67
Introduction
Introduction
Les boucles permettent de réepéter une série d’instructions
tant qu’une certaine condition n’est pas vérifiée.
En C, nous disposons de trois structures qui nous permettent
la définition de boucles conditionnelles :
1 la structure : while
2 la structure : do - while
3 la structure : for
29/67
Outline

30/67
while
Il s’agit de l’instruction : tant que (expression vraie)

faire{BLOC D’INSTRUCTIONS}
Organigramme
31/67
while
Syntaxe en C :
while (expression)
{
............;
............;
}
32/67
while
La partie < expression > peut désigner :

1 une variable d’un type numérique,
2 une expression fournissant un résultat numérique.
Tant que expression est vérifiée (i.e., non nulle), instruction
est exécutée. Si expression est nulle au départ, instruction ne
sera jamais exécutée.
instruction peut évidemment être une instruction composée.
les {} ne sont pas nécessaires lorsque le bloc ne comporte
qu’une seule instruction.
Le test se fait d’abord, le bloc d’instructions n’est pas
forcément exécuté.
33/67
while
La partie < blocd 0 instructions > peut désigner :

1 un (vrai) bloc d’instructions compris entre accolades,
2 une seule instruction terminée par un point-virgule.
Remarque :
On peut rencontrer la construction suivante : while (expression) ;
terminée par un ; et sans la présence du bloc d’instructions.
Cette construction signifie : ”tant que l’expression est vraie
attendre”.
34/67
while
Exemple
le programme suivant imprime les entiers de 1 à 9.
i = 1;
while (i < 10)
{
printf("\n i = %d",i);
i++;
}
35/67
Outline

36/67
do ... while
Il s’agit de l’instruction : répéterBLOC D’INSTRUCTIONS

tant que (expression vraie)
Organigramme
37/67
do ... while
Syntaxe en C :
do
{
............;
............;
}
while (expression);
38/67
do ... while
L’instruction à répéter peut être simple (une seule action),

structurée (une autre instruction de contrôle) ou composée
(c’est le cas le plus fréquent).
le test de continuation n’est évalué qu’après avoir exécuté
l’instruction.
Le test se faisant après, le bloc est exécuté au moins une fois.
les {} ne sont pas nécessaires lorsque le bloc ne comporte
39/67
do ... while
Exemple
int n, div;
printf("Entrez le nombre à diviser : ");
scanf("%i", &n);
do
{
printf("Entrez le diviseur (!0) : ");
scanf("%i", &div);
}
while (!div);
printf("%i / %i = %f\n", n, div, (float)n/div);
40/67
Outline

41/67
for ...
Il s’agit de l’instruction :
pour (initialisation ; condition de continuité vraie ;modification)
{BLOC D’INSTRUCTIONS}
Organigramme
42/67
for ...
Syntaxe en C :
for(initialisation ; condition de continuité ;

modification)
{
............;
............;
}
43/67
for ...
1 < initialisation > est évaluée une fois avant le passage de la

boucle. Elle est utilisée pour initialiser les données de la
boucle.
2 < condition de continuité > est évaluée avant chaque
passage de la boucle. Elle est utilisée pour décider si la
boucle est répétée ou non.
3 < modification > est évaluée à la fin de chaque passage de
la boucle. Elle est utilisée pour réinitialiser les données de la
boucle.
44/67
for ...
Remarques :
Les ne sont pas nécessaires lorsque le bloc ne comporte
Les 3 instructions du for ne portent pas forcément sur la
même variable.
Une instruction peut être omise, mais pas les ;
Les trois expressions utilisées dans une boucle for peuvent être
constituées de plusieurs expressions séparées par des
virgules(,). Cela permet par exemple de faire plusieurs
initialisations à la fois.
45/67
for ...
Exemples :
for(i = 0 ; i<10 ; i++)

{
............;
............;
}
46/67
for ...
Exemples :
Le plus souvent, for est utilisé comme boucle de comptage :
for ( <init.> ; <cond. répétition> ; <compteur> )

<bloc d'instructions>
Exemple
int I;
for (I=0 ; I<=20 ; I++)
printf("Le carré de %d est %d \n", I, I*I);
47/67
for ...
for ( <expr1> ; <expr2> ; <expr3> )

est équivalent à :
<expr1>;
while ( <expr2> )
{
<expr3>;
}
48/67
for ...
La boucle
for(;;)
{
...........; /* bloc d'instructions */
............;
............;
}
est une boucle infinie (répétition infinie du bloc d’instructions).
49/67
for ...
Utilisation de variables différentes :
resultat = 0;
for(i = 0 ; resultat<30 ; i++)
{
............;
............;
resultat = resultat + 2*i;
}
50/67
Outline

51/67
Choix entre boucles
Utilisez la structure qui reflète le mieux l’idée du programme que

vous voulez réaliser, en respectant toutefois les directives
suivantes :
Si le bloc d’instructions ne doit pas être exécuté si la
condition est fausse, alors utilisez while ou for.
Si le bloc d’instructions doit être exécuté au moins une fois,
alors utilisez do - while.
Si le nombre d’exécutions du bloc d’instructions dépend d’une
ou de plusieurs variables qui sont modifiées à la fin de chaque
répétition, alors utilisez for.
Si le bloc d’instructions doit être exécuté aussi longtemps
qu’une condition extérieure est vraie (p.ex aussi longtemps
qu’il y a des données dans le fichier d’entrée), alors utilisez 52/67
while. Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
Choix entre boucles
Le choix entre for et while n’est souvent qu’une question de

préférence ou d’habitudes :
for nous permet de réunir avantageusement les instructions qui
influencent le nombre de répétitions au début de la structure.
while a l’avantage de correspondre plus exactement aux
structures d’autres langages de programmation (while, tant
que).
for a le désavantage de favoriser la programmation de
structures surchargées et par la suite illisibles.
while a le désavantage de mener parfois à de longues
structures, dans lesquelles il faut chercher pour trouver les
instructions qui influencent la condition de répétition.
53/67
Les structures alternatives Branchement non conditionnel break
LEs structures répetitives Branchement non conditionnel continue
Les instructions de branchement non conditionnel Branchement non conditionnel goto
Outline

Branchement non conditionnel break
Branchement non conditionnel continue
Branchement non conditionnel goto
54/67
break
break
Au sein d’une instruction de branchement multiple switch.
L’instruction break peut, plus généralement, être employée à
l’intérieur de n’importe quelle boucle.
Attention
Elle permet d’interrompre le déroulement de la boucle, et
passe à la première instruction qui suit la boucle.
break termine l’instruction do, for, switch ou while le plus près.
En cas de boucles imbriquées, break fait sortir de la boucle la
plus interne.
55/67
break
Par exemple, le programme suivant :
main()
{
int i;
for (i = 0; i < 5; i++)
{
printf("i = %d\n",i);
if (i == 3)
break;
}
printf("valeur de i a la sortie de la boucle = %d\n",
i);
56/67
} Pr Mostafa SAADI – ENSAK Programmation C : Conditions et Boucles
break
Résultats
imprime à l'écran
i = 0
i = 1
i = 2
i = 3
valeur de i a la sortie de la boucle = 3
57/67
Outline

58/67
continue
continue
L’instruction continue permet de passer directement au tour
de boucle suivant, sans exécuter les autres instructions de la
boucle.
continue passe à la prochaine itération des instructions do, for
ou while
59/67
continue
Par exemple, le programme suivant :
main()
{
int i;
for (i = 0; i < 5; i++)
{
if (i == 3)
continue;
printf("i = %d\n",i);
}
printf("valeur de i a la sortie de la boucle = %d\n",
i);
60/67
break
Résultats
imprime
i = 0
i = 1
i = 2
i = 4
valeur de i a la sortie de la boucle = 5
61/67
Outline

62/67
goto
goto
L’instruction goto permet d’effectuer un saut jusqu’à
l’instruction étiquette correspondante.
goto passe directement à l’étiquette spécifiée
étiquette : instruction
Une étiquette est un identificateur ;
elle doit être placée devant une fonction, séparée de celle-ci
par un caractère deux points.
63/67
goto
goto
Une étiquette n’a pas à faire l’objet d’une déclaration
explicite ; il suffit de l’écrire devant une instruction pour qu’elle
soit automatiquement connue comme un nom à porté locale.
Elle est alors utilisable partout dans la fonction où elle
apparait (avant et après l’instruction qu’elle préfixe) et elle
reste inconnue en dehors de la fonction.
64/67
goto
L’instruction :
goto étiquette ;
transfère le contrôle à l’instruction préfixée par l’étiquette en
question.
Théoriquement, tout algorithme peut être programmée sans
utiliser l’instruction goto.
Elle est utilisée pour obtenir l’abandon d’une structure de
contrôle (exemple : une boucle) depuis l’intérieur de la
structure.
Un tel emploi de goto est avantageusement remplacée en C
par l’utilisation des instructions return, break et continue.
Il est donc rare que l’on ait besoin de l’instruction goto en C.
65/67
Elle ne se révèle utile que lorsqu’il faut abandonner plusieurs
goto
for (i = 0; i < N1; i++) {

for (j = 0; j <= N2; j++)
for (k = 0; k <= N2; k++) {
...
if (...)
goto grande_boucle;
...
}
...
grande_boucle: /* ici on a quittée les deux boucles
internes (sur j et k) */
... /* mais on est toujours dans la boucle la plus
externe (sur i) */ 66/67
The End
67/67

Chap02 CondtionsBoucles

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

Chap02 CondtionsBoucles

Transféré par

Droits d'auteur :

Formats disponibles

Les structures alternatives

LEs structures répetitives

Les structures altérnatives et

L’Ecole Nationale des Sciences Appliquées à Khouribga

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

Le bloc ”sinon” est optionnel :

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

L’instruction SI ... ALORS ... SINON SI ...

L’instruction SI ... ALORS ... SINON SI ...

L’instruction SI ... ALORS ... SINON SI ...

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

Les opérateurs logiques

if (a==b) " si a égal b "

test de non égalité :

if (a!=b) " si a différent de b "

tests de relation d’ordre :

if (a<b) if (a<=b) if (a>b) if (a>=b) 13/67

Les opérateurs logiques

if ((expression1) && (expression2))

Les opérateurs logiques

test de NON LOGIQUE

Toutes les combinaisons sont possibles entre ces tests.

Les opérateurs logiques

Le langage C admet des écritures contractées dans les expressions

char reponse; char reponse;

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

Les opérateurs conditionnels

Le langage C possède une paire d’opérateurs ( : et ?) un peu

<expr1> ? <expr2> : <expr3>

Si < expr 1 > fournit une valeur différente de zéro, alors la

Les opérateurs conditionnels

Les opérateurs conditionnels

printf("Vous avez %i carte%c \n", N, (N==1|| N==0) ?

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel

switch ... case

L’instruction switch permet des choix multiples uniquement sur

L’instruction switch correspond à une cascade d’instructions if

switch ... case

switch(variable de type char ou int)//au cas où la

switch ... case

switch ... case

switch ... case

switch ... case

switch ... case

case '2': ......;

case 'S': printf("\nFIN DU PROGRAMME ....");

default; printf("\nCE CHOIX N'EST PAS PREVU "); /*

1 Les structures alternatives

2 LEs structures répetitives

3 Les instructions de branchement non conditionnel