Introduction au langage C : Structures de contrôle
1
èreannée Génie Informatique Dr Daouda Traoré
Université de Ségou
email: [email protected]
Introduction
On appelle structure conditionnelle les instructions qui
permettent de tester si une condition est vraie ou non, c’est-à- dire si la valeur de son expression vaut 0 ou 1 (le langage JAVA associe le mot-clé true à 1 et false à 0). Ces structures
conditionnelles peuvent être associées à des structures qui se
répètent suivant la réalisation de la condition, on appelle ces
structures des structures de boucle.
Introduction
Pour agir sur le déroulement de l’exécution, les langages offrent des structures de contrôle
Conditionnelle ou alternative : embranchement dans l’exécution en fonction d’une condition.
Itérative : exécution répétitive (boucle), l’arrêt étant soit déterminé au
préalable (répéter) ou dépendant d’une condition de continuation (tant que)
Structure conditionnelle
Une structure conditionnelle permet d’effectuer des choix (alternative) ou de faire un choix parmi plusieurs.
Instruction : « si-alors-sinon »
si (expression conditionnelle égale à vraie) alors { séquence1 d’ instructions;}
sinon { séquence2 d’ instructions;}
Sequence1 d’instructions
Sequence2 d’instructions Suite du programme
vraie fausse
Expression
conditionnelle
Structure conditionnelle if
L’instruction if est la structure de test la plus basique, on la retrouve dans les tous langages (avec une syntaxe parfois différente d’un langage à l’autre). Elle permet d’exécuter une série d’instructions (un bloc d’instructions) si jamais une
condition est réalisée.
La syntaxe de l’instruction if est généralement la suivante : if (expression conditionnelle vérifiée) {
séquence d’ instructions;
}
La condition doit être entre parenthèses
IL est possibles de définir plusieurs conditions avec les opérateurs ET et OU (en C : && et ||).
S’il n’y a qu’une instruction dans le bloc d’instruction, les accolades ne sont pas toujours nécessaires (en revanche les parenthèses le sont):
if (a==3) printf("a est un nombre impair \n");
Structure conditionnelle : Opérateurs ET et OU en C
L’instruction if suivante teste si les deux conditions sont réalisées :
if ((condition1) && (condition2) ) { séquence d’ instructions;
}
L’instruction if suivante exécutera les instructions si l’une ou l’autre des deux conditions est réalisée :
if ((condition1) || (condition2) ) { séquence d’ instructions;
}
Structure conditionnelle if…else
L’instruction if dans sa forme basique ne permet de tester qu’une condition, or la plupart du temps on aimerait pouvoir choisir les
instructions à exécuter en cas de non-réalisation de la condition.
L’instruction if…else permet d’exécuter une autre série d’instruction en cas de non-réalisation de la condition.
La syntaxe de l’instruction if…else est généralement la suivante : if (expression conditionnelle vérifiée) {
séquence d’ instructions;
} else {
autre séquence d’ instructions }
Les structures conditionnelles pouvant être imbriquées, il peut être utile
d’indenter le code pour plus de lisibilité, c’est-à-dire de décaler à l’aide
d’une tabulation chaque bloc d’instruction pour pouvoir rapidement
visualiser l’imbrication des structures !
Structure conditionnelle
En C une expression est vraie si sa valeur est égale à 1 et elle est fausse si sa valeur est égale à 0.
Exemple d’une structure conditionnelle en C:
A;
if(test) B;
else C;
D;
test A
D
B C
1 0
-- « test » expression à évaluer -- « A,B,C,D » sont des instructions -- Déroulement de if :
- l’expression « test » est évaluée :
- Si elle est égale à 1 :
l’instruction B est exécutée;
- Si elle est égale à 0 :
l’instruction C est exécutée;
- L’instruction D est évaluée
ensuite
Les différentes formes du if
if avec blocs if(E) {
A1; A2, ...; An;
} else {
B1; B2, ...; Bn;
}
if sans else if(E) {
A1; A2, ...; An;
}
E
A1,A2;..An; B1,B2;..Bn;
IF
E
A1,A2;..An;
IF
1 0
0
1
Les différentes formes du if
if emboités if(E1) { if(E2) {
A1; A2, ...; An;
} else {
B1; B2, ...; Bn;
} } else {
C1; C2, ...; Cn;
}
E1
E2
A1,A2;..An; B1,B2;..Bn; C1,C2;..Cn;
IF
0 1
1
0
Les différentes formes du if
if emboités if(E1) {
A1; A2, ...; An;
} else { if(E2) {
B1; B2, ...; Bn;
} else {
C1; C2, ...; Cn;
}
} // vesion 1
if emboités if(E1) {
A1; A2, ...; An;
} else if(E2) {
B1; B2, ...; Bn;
} else {
C1; C2, ...; Cn;
}
} // vesion 2
Exercice : Donner une représentation graphique de ce if
Exemple : calcul du maximum de deux entiers
Calcul du maximum de deux entiers int a, b, max;
if(a > b) { max=a;
} else { max=b;
}
Exemple : calcul du maximum de trois entiers
int a, b, c, max;
if(a > b) { if(a > c) { max=a;
} else { max=c;
} } else { if(b > c) { max = b;
} else { max =c;
} }
int a, b, c, max;
if( (a > b) && (a > c)) { max=a;
} else if ((b > a) && (b > c)) { max=b;
} else { max =c;
}
Représentation graphique du calcul du maximum de trois entiers
a > b
a > c
max=a; max=c;; max=c
Max
0 1
1 0
b > c
;max=b
1 0
Exemple dans un programme
#include <stdio.h>
main() {
int a, b, c, max;
printf("Donnez un premier entier : ");
scanf("%d", &a);
printf("Donnez un deuxième entier : ");
scanf("%d ", &b);
printf("Donnez un troisième entier : ");
scanf("%d ", &c);
if( (a > b) && (a > c)) { max=a;
} else if ((b > a) && (b > c)) { max=b;
} else { max =c;
}
printf("Le maximun de %d, %d, %d est %d : \n", a, b, c, max);
}
Les boucles sont des structures permettant d’exécuter plusieurs fois la même série d’instructions jusqu’à ce qu’une condition ne soit plus réalisée.
Les variantes se différencient par la manière de caractériser le nombre de boucles effectivement réalisées.
Tant que
: on exprime la condition de continuation
Répéter…tant que : on exprime la condition d’arrêt
pour : on exprime le décompte exact de boucles
Structures de boucle (itération)
L’instruction while (tant que) permet d’exécuter plusieurs fois la même série d’instructions. Elle se présente sous la forme suivante :
while (expression est vraie ) { séquence d’ instructions;
}
Exemple : exécuter l’instruction A, puis tant que E est vraie faire B et si E est fausse faire C;
L’instruction while
E B
C A
1
0 A;
while(E) { B;
}
C;
Expression constitue la condition de poursuite de la boucle. La présence des parenthèses permet de délimiter cette condition.
Expression est évaluée avant le premier tour de boucle. Il est donc nécessaire que sa valeur soit définie à ce moment.
On doit assurer la convergence (arrêt de la boucle) : la condition doit à un moment donné s’évaluer à faux.
Condition nécessaire : la condition doit faire intervenir une variable qui sera modifiée dans le corps de boucle
Dans le cas d’une conjonction de conditions (while( E1 && E2)…)
L’arrêt est provoquée quand l’une des deux conditions s’évalue à faux
La condition d’arrêt est alors : !E1 || !E2
L’instruction while
while(Expression) {
sequence d’instructions;
}
//Moyenne d’une série de notes saisies au clavier
#include <stdio.h>
main() { double note;
double somme = 0;
int nbNote = 0;
printf(" Donnez une note >=0 ou -1 pour terminer : ");
scanf(" %lf ", ¬e);
while(note!=-1) {
somme = somme + note;
nbNote = nbNote+1;
printf(" Donnez une note >=0 ou -1 pour terminer : ");
scanf(" %lf ", ¬e);
}
printf(" Le nombre de notes saisies est : %d \n", nbNote);
printf(" La moyenne est des notes saisies est : %f \n", (somme)/nbNote);
}
L’instruction while : exemples de
programmes
//Saisie avec filtre : saisie d’une note entre 0 et 20
#include <stdio.h>
main() {
double note;
printf(" Donnez une note : ");
scanf(" %lf ", ¬e);
while(note < 0 || note > 20) {
printf("la note saisie est incorrecte, veuillez resaisir : ");
scanf(" %lf ", ¬e);
}
}L’instruction while : exemples de
programmes
//PGCD (plus grand commun diviseur
#include <stdio.h>
main() { int a, b;
printf("Donnez un entier :");
scanf("%lf ", &a);
printf("Donnez un entier :");
scanf("%lf ", &b);
int x=a, y=b;
if(a < 0) a=-a;
if(b < 0) b=-b;
while(a!=b) { if(a < b) b=b-a;
else a = a-b;
}
printf("Le pgcd de %d et %d est : %d", x,y, a);
}
L’instruction while : exemples de
programmes
/* Enigme mathématique : on montre que le programme suivant converge toujours quelque soit l’entier n > 0 au depart*/
#include <stdio.h>
#include <stdlib.h>
main() {
int n; // valeur de n au depart int cpt = 1; // compteur d’itérations while(n!=1) {
if(n%2==0) n=n/2;
else n=3*n+1;
cpt++;
printf("n=%d" , n);
}
printf(("Convergence en %d itérations\n" , cpt);
}
//exmple pour n=100, on fait 26 itérations
L’instruction while : exemples de
programmes
L’instruction for(pour) représente un autre moyen d’exécuter plusieurs fois la même série d’instructions. Dans sa syntaxe, il suffit de préciser :
Le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ),
La condition sur la variable pour laquelle la boucle s’arrête (basiquement une condition qui teste si la valeur dépasse une limite)
Une instruction qui incrémente (ou décrémente) le compteur.
Elle se présente sous la forme suivante :
for (compteur; condition; modification du compteur) { séquence d’ instructions;
}
L’instruction for
Exemple : exécuter l’instruction A, puis exécuter N fois l’instruction B; puis après l’instruction C
L’instruction for
B
C int i; A
A; for(i=0; i!=N; i++) { B;
} C;
Répéter N fois
L’instruction for : schéma détaillé de l’exemple
B
C A int i;
A; for(i=1; i!=11; i++) { B;
} C;
Répéter 10 fois
i=1
i!=11
i++
/* programme qui calcule la factorielle d’un entier positif n; !n=1*2*3*….n*/
#include <stdio.h>
#include <stdlib.h>
main() { int n;
int i;
int fact = 1; //initialisation du calcul
printf("Donnez un entier strictement positif :");
scanf("%d ", &n);
for(i=1; i!=n+1; i++) { printf("%d", i);
fact = fact*i;
}
printf("\nFactorielle de %d = %d\n" ,n,fact);
}
//exmple pour !10=3628800
L’instruction for : exemples de
programmes
Partie initialisation
Il peut y avoir plusieurs expressions séparées par des virgules,
Exemple for(i=0, j=1; …)
Les variables se nomment itérateurs ou indice de boucle
Partie condition
Expression quelconque (booléenne) qui détermine la condition de continuation (en génarale atteinte d’une borne)
Exemple :
for (i=1; i!=11; i=i+2) A; // « A » exécuté 5 fois
for (i=0; i!=11; i=i+2) A; // « A » exécuté indéfiniment for (i=1; i < 11; i=i+2) A; // « A » exécuté 5 fois
for (i=1; i<=10; i=i+2) A; // « A » exécuté 5 fois
L’instruction for : forme générale
Partie incrémentation
L’expression doit impérativement modifier l’itérateur : incrémentation, décrementation, de 1 en 1, de n en n….
Exécuter après le contenu de la boucle
Comme pour la partie initialisation, il peut y avoir plusieurs expressions séparées par des virgules
Exemple :
for (i=0, j=10; i<=j; i++, j--) { printf("i=%d j=%d /n",i,j);
}
Partie instruction
Instruction simple ou bloc (en {})
Possibilité d’emboiter des boucles
L’instruction for : forme générale
L’instruction for : exemples de programmes
/* Incrément de n en n : affichage des multiples de n inférieurs à 100*/
#include <stdio.h>
#include <stdlib.h>
main() { int n;
int i;
int max = 100;
printf("Donnez un nombre inferieur à 100 :");
scanf("%d", &n);
for(i=n; i < max; i=i+n) { printf("%d ", i);
} }
L’instruction for : exemples de programmes
/* Boucles emboitées : affichage d’un rectangle de nbL lignes de nbC étoiles*/
#include <stdio.h>
#include <stdlib.h>
main() { int nbL;
int nbC;
int ligne;
int colonne;
printf("Donnez le nombre de lignes :");
scanf("%d", &nbL);
printf("Donnez le nombre de colonnes :");
scanf("%d", &nbC);
for(ligne=1; ligne <= nbL; ligne++) {
for(colonne=1; colonne <= nbC; colonne++) { printf("*");
}
printf("\n");
} }
L’instruction for : exemples de programmes
/* Boucles emboitées : affichage d’un triangle de nbL lignes*/
#include <stdio.h>
#include <stdlib.h>
main() { int nbL;
int ligne;
int colonne;
printf("Donnez le nombre de lignes :");
scanf("%d", &nbL);
for(ligne=1; ligne <= nbL; ligne++) {
for(colonne=1; colonne <= ligne; colonne++) { printf("*");
}
printf("\n");
} }
L’instruction for : exemples de programmes
/* calcul de x a la puissance n*/
#include <stdio.h>
#include <stdlib.h>
main() { int x;
int n;
int p;
int resultat=1; //initialisation du calcul printf("Donnez la valeur de x :");
scanf("%d", &x);
printf("Donnez la valeur de n :");
scanf("%d", &n);
for(p=1; p <= n; p++) { resultat = resultat*x;
}
printf("Resultat : %d\n",resultat);
}
L’instruction for : exemples de programmes
/* Saisie de n nombres et calcul de la moyenne*/
#include <stdio.h>
#include <stdlib.h>
main() { int n;
int i;
int noteCourant;
double somme=0; //initialisation du calcul
printf("Donnez le nombre de notes que vous voulez saisir:");
scanf("%d", &n);
for(i=1; i <= n; i++) { printf("Note %d :" ,i);
scanf("%d", ¬eCourant);
somme = somme+noteCourant;
}
printf("Moyenne : %f\n",(somme)/n);
}
Le for (pourtout) est un cas particulier du while (tantque) for (i=binf;i <=bsup;i++) P; int i=binf;
while(i < bsup) { P;
i++;
}
Plus généralement :
for (E1;E2;E3;) P; E1;
while(E2) { P;
E3;
}
Equivalence d’un while et d’un for
L’instruction continue dans une boucle permet de faire sauter à la boucle une ou plusieurs valeurs sans mettre fin à celle-ci. Elle est
généralement associée à une structure conditionnelle, sinon les lignes situées entre cette instruction et la fin de la boucle seraient obsolètes.
Exemple d’utilisation dans une boucle : int n = 0;
printf("Les nombres pairs entre 0 et 20\n");
while(n <= 20) { if(n%2==1) { n++;
continue;
}
printf("%d ",n);
n++;
}
Saut inconditionnel
L’instruction break permet d’arrêter prématurément une boucle. Elle est généralement associée à une structure conditionnelle, sans laquelle la boucle ne ferait jamais plus d’un tour!.
Exemple d’utilisation dans une boucle : int n = 0;
printf("Recherche de la racine carres de 144 dans une suite d’entier entre 0 et 20\n");
while(n <= 20) {
if(n*n==144) {
printf("La Racine carree de 144 est %d ", n);
break;
}
n++;
}
Arrêt inconditionnel
L’instruction swhitch permet de faire plusieurs tests de valeurs sur le contenu d’une même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d’une variable, car cette opération aurait été compliquée (mais possible) avec des if imbriquées .
Sa syntaxe est la suivante :
switch(Variable) { case Valeur1:
sequence d’instructions;
break;
case Valeur2:
sequence d’instructions;
break;
case ValeurX:
sequence d’instructions;
break;
default:
sequence d’instructions;
break;
}
L’instruction switch…case
Les parenthèses qui suivent le mot-clé swhitch indiquent une expression dont la valeur est testée successivement par chacun des case. Lorsque l’expression testée est égale à une des
valeurs suivant un case, la liste d’instructions qui suit celui-ci est exécutée.
Le mot-clé break indique la sortie de la structure conditionnelle.
Le mot-clé default précède la liste d’instructions qui sera exécutée si l’expression n’est jamais égale à une des valeurs.
L’instruction switch…case
L’instruction switch…case : exemples de programmes
main() { int n;
printf("Donnez un entier:");
scanf("%d", &n);
switch(n) {
case 0:
printf(" Vous avez saisi ZERO \n"); break;
case 1:
printf(" Vous avez saisi UN \n");break;
case 2:
printf(" Vous avez saisi DEUX \n");break;
default :
printf(" Vous avez saisi un nombre superieur a 2 \n"); break;
}
printf("au revoir\n");
}
L’instruction do…while (repeterjusqua) est un autre moyen d’exécuter
plusieurs fois la même série d’instructions. Elle est toujours parcourue au moins une fois. La condition d’arrêt n’est examinée qu’à la fin de chaque répétition.
Elle se présente sous la forme suivante : do {
séquence d’ instructions;
} while (expression est vraie );
Commentaire :
Notez bien, la présence de parenthèses autour de l’expression qui régit la poursuite de la boucle, d’autre part la présence d’un point-virgule à la fin de cette instruction.
Lorsque l’instruction à répéter se limite à une seule instruction simple, n’omettez pas le point-virgule qui la termine.
L’instruction do…while
L’instruction do…while : exemples de programmes
main() {
int n;
do {
printf("Donnez un entier superieur a zero :");
scanf("%d", &n);
printf("Donnez avez fourni %d\n" ,n);
} while(n <=0) ;
printf("reponse correcte\n");
}
