École Supérieure de Technologie
et d’Informatique
A.U. 2011/2012
Cours programmation en langage C
Chapitre 4 : Les structures alternatives et répétitives ( 11 pages)
Informatique Appliquée 1ère année
En langage C, on peut :
(cid:1)
(cid:1)
faire des choix (if.. else et switch)
faire des boucles (répéter plusieurs fois un ensemble donné d’instructions) (do..while,
while et for)
Instructions de branchement inconditionnel: goto, break, continue
(cid:1)
(cid:1) Bloc: suite d’instructions placées entre { };
(cid:1) Les instructions dans un bloc peuvent être des instructions simples ou des instructions
structurées (choix, boucle) lesquelles peuvent à leur tour renfermer d’autres blocs.
(cid:1) Dans un bloc composé d’une seule instruction, les accolades sont facultatives
syntaxe de if ..else
if ( <expression> )
<bloc d'instructions 1>
else <bloc d'instructions 2>
(cid:1) Si l'<expression> fournit une valeur différente de zéro, alors le <bloc d'instructions 1>
est exécuté
(cid:1) Si l'<expression> fournit la valeur zéro, alors le <bloc d'instructions 2> est exécuté
(cid:1) La partie <expression> peut désigner :
o une variable d'un type numérique
o une expression fournissant un résultat numérique.
(cid:1) 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.
o
instruction structurée
Exemple 1 :
Ecrire un programme qui lit un entier au clavier et affiche entier positif, s’il est supérieur
ou égal à zéro, ou affiche entier négatif s’il est strictement négatif.
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier”);
scanf(“%d”, &x);
if (x>=0)
{
printf(“entier positif”); //ce bloc contient une seule instruction
}
else
Mme Wiem Yaiche Elleuch chapitre 4
1
{
printf(“entier négatif”); //ce bloc contient une seule instruction
}
}
Remarque :
Les blocs qui suivent le if et le else contiennent une seule instruction. Les accolades sont
donc facultatives. Le programme peut s’écrire ainsi :
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier”);
scanf(“%d”, &x);
if (x>=0)
else
printf(“entier positif”);
printf(“entier négatif”);
}
Exemple 2 :
Ecrire un programme qui lit deux entiers différents, et affiche le maximum
#include <stdio.h>
void main()
{
int x,y;
printf(“saisir deux entiers ”);
scanf(“%d%d”, &x,&y) ;
if (x>y) printf(« le maximum est %d », x) ;
else printf(« le maximum est %d », y) ;
}
Exemple 3 :
Ecrire un programme qui lit un entier au clavier et affiche entier positif, s’il est strictement
positif, ou affiche entier négatif s’il est strictement négatif, ou affiche entier nul s’il est
égal à zéro.
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier”);
scanf(“%d”, &x);
if (x>0) printf(“entier positif”);
else if (x<0) printf(“entier négatif”);
else printf (“entier nul”);
}
Mme Wiem Yaiche Elleuch chapitre 4
2
Publicité
Exemple 4 :
Ecrire un programme qui lit un entier au clavier et affiche ZERO si l’entier est égal à 0, UN
si l’entier est égal à 1, DEUX si l’entier est égal à 2, AUTRE sinon.
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier “);
scanf(“%d”, &x);
if(x==0) printf(“ ZERO”);
else if (x==1) printf(“ UN” );
else if (x==2) printf(“ DEUX “);
else printf(“ AUTRE “);
}
Exemple 5 :
Ecrire un programme qui lit un entier au clavier et affiche Lundi si l’entier est égal à 1,
Mardi si l’entier est égal à 2,….. Dimanche si l’entier est égal à 7, Autre sinon.
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier “);
scanf(“%d”, &x);
if ( x==1) printf(« Lundi » ) ;
else if ( x==2) printf(« Mardi » ) ;
else if ( x==3) printf(« Mercredi » ) ;
else if ( x==4) printf(« Jeudi » ) ;
else if ( x==5) printf(« Vendredi » ) ;
else if ( x==6) printf(« Samedi » ) ;
else if ( x==7) printf(« Dimanche » ) ;
else printf(« Autre » ) ;
}
L’instruction switch …case
switch (expression)
{
case constante_1: [suite_inst_1] ; break ;
case constante_2: [suite_inst_2] ; break ;
case constante_3: [suite_inst_3] ; break ;
[default: suite_inst] ;
}
Exécution de switch …case
(cid:1) Évaluer l’expression figurant après le mot switch
(cid:1) Rechercher dans le bloc qui suit s’il existe une étiquette de la forme «constante_i »
correspondant à la valeur ainsi obtenue
(cid:1) Si c’est le cas, on se branche à l’instruction figurant après cette étiquette
(cid:1) Dans le cas contraire on passe à l’instruction qui suit le bloc
(cid:1) Remarque: l’instruction break demande de sortir du bloc
Mme Wiem Yaiche Elleuch chapitre 4
3
Exemple :
Reprendre l’exemple 4, et réécrire le programme en utilisant switch ... case au lieu de
if….else
#include <stdio.h>
void main()
{
int x;
printf (“ donner un entier “);
scanf(“%d”, &x);
// debut du switch
switch (x)
{
case 0: printf(“ ZERO “); break;
case 1: printf(“ UN “);
break;
case 2: printf(“ DEUX “); break ;
default: printf (“AUTRE”); break ; // ce break est facultatif
}
printf(« fin du travail ») ;
// fin du switch
}
Si on saisit 0, on aura l’affichage ZERO fin du travail
Remarque :
(cid:1) Le break qui suit l’instruction default: printf (“AUTRE”); est facultatif, puisque le
programme quittera automatiquement le switch et passera à l’instruction
printf(« fin du travail ») ;
(cid:1) Si on ne met pas les break à la fin de chaque instruction de la manière suivante :
#include <stdio.h>
void main()
{
int x;
printf (“ donner un entier “);
scanf(“%d”, &x);
switch (x)
{
case 0: printf(“ ZERO “);
case 1: printf(“ UN “);
case 2: printf(“ DEUX “);
default: printf (“AUTRE”);
}
printf(« fin du travail ») ;
}
Si on saisit 0, on aura l’affichage : ZERO UN DEUX AUTRE fin du travail
Exemple :
Reprendre l’exemple 5, et réécrire le programme en utilisant switch ... case au lieu de
Publicité
if….else
Mme Wiem Yaiche Elleuch chapitre 4
4
#include <stdio.h>
void main()
{
int x;
printf(“saisir un entier “);
scanf(“%d”, &x);
switch (x)
{
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(« Autre » ) ;
}
}
Mme Wiem Yaiche Elleuch chapitre 4
5
Les structures répétitives
En C, il existe trois structures qui permettent la définition de boucles conditionnelles:
1) la structure : while
2) la structure : do - while
3) la structure : for
La boucle while
while ( <expression> )
<bloc d'instructions>
(cid:1) Tant que l'<expression> fournit une valeur différente de zéro, le <bloc
d'instructions> est exécuté.
(cid:1) Si l'<expression> fournit la valeur zéro, l'exécution continue avec l'instruction qui
suit le bloc d'instructions.
(cid:1) Le <bloc d'instructions> est exécuté zéro ou plusieurs fois.
(cid:1) La partie <expression> peut désigner :
o une variable d'un type numérique
o une expression fournissant un résultat numérique.
(cid:1) 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.
(cid:1) Pas de point virgule après while (…)
(cid:1) La condition de poursuite est évaluée avant le premier tour de boucle. Il est donc
nécessaire que sa valeur soit définie
Exemple :
Ecrire un programme qui affiche les entiers de 1 à 3 en utilisant une boucle while.
#include<stdio.h>
void main()
{
int i=1 ;
while (i<=3)
{
printf(« l’entier est %d »,i) ;
i++ ;
}
printf(« %d », i) ;
printf(« fin du travail » ) ;
}
Exécution
l’entier est 1
l’entier est 2
l’entier est 3
4
fin du travail
// i prend la valeur 4 à la sortie de la boucle
Mme Wiem Yaiche Elleuch chapitre 4
6
Exemple 2 :
Ecrire un programme qui lit des entiers. Le nombre d’entiers à lire n’est pas connu à
l’avance. Le programme s’arrêtera de lire les entiers quand leur somme dépasse 100.
#include <stdio.h>
void main()
{
int n, som=0;
while (som<100)
{
printf(« donner un nombre »);
scanf(« %d »,&n);
som+=n;
}
printf(« la somme obtenue %d », som);
}
La boucle do …while
do
<bloc d'instructions>
while ( <expression> );
Publicité
(cid:1) La structure do - while est semblable à la structure while, avec la différence suivante :
o while évalue la condition avant d'exécuter le bloc d'instructions,
o do - while évalue la condition après avoir exécuté le bloc d'instructions. Ainsi le
bloc d'instructions est exécuté au moins une fois.
Exemple :
Ecrire un programme qui saisit un entier strictement positif ensuite l’affiche. Le programme
doit faire un test sur l’entier lu.
#include <stdio.h>
void main()
{
int n;
do
{
printf(« donner un nombre strictement positif »);
scanf(«%d », &n);
}
while (n<=0);
printf(“l’entier lu est %d”, n);
}
(cid:1) do {…..} while (n<=0)
(cid:1) Répète le bloc { } tant que la condition est vraie (nulle)
(cid:1) On ne sait pas a priori combien de fois une telle boucle sera répétée
(cid:1) Toutefois, elle est toujours parcourue au moins une fois
Mme Wiem Yaiche Elleuch chapitre 4
7
Exemple 2 :
Ecrire un programme qui lit un entier compris entre 1 et 10.
#include <stdio.h>
void main()
{
int n;
do
{
printf("saisir un nombre entre 1 et 10 ");
scanf("%d", &n);
}
while (n<1 || n>10);
printf(“l’entier lu est %d”, n);
}
Exemple 3
Ecrire un programme qui lit deux entiers, et divise le premier par le second (diviseur), celui-
ci doit être différent de zéro.
#include <stdio.h>
void main()
{
int n, div;
printf("Entrez le nombre à diviser : ");
scanf("%d", &n);
do
{
printf("Entrez le diviseur ( différent de 0) : ");
scanf("%d", &div);
}
while (!div); // (cid:2) while (div ==0)
printf("%d / %d = %f ", n, div, (float)n/div);
Exemple 3
Ecrire un programme qui lit un entier positif, et calcule sa racine carré.
#include <stdio.h>
#include <math.h>
main()
{
float n;
do
{
printf("Entrer un nombre positif : ");
scanf("%f", &n);
}
while (n < 0);
printf("La racine carrée de %.2f est %.2f ", n, sqrt(n));
}
Mme Wiem Yaiche Elleuch chapitre 4
8
L’instruction for
for ( [<expr1>] ; [<expr2>] ; [<expr3>] )
<bloc d'instructions>
Ce schéma est équivalent au schéma suivant de while
<expr1>;
while ( <expr2> )
{
<bloc d'instructions>
<expr3>;
}
L’instruction for :
(cid:1) <expr1> Elle est utilisée pour initialiser les données de la boucle. Elle est évaluée
une seule fois avant d’entrer dans la boucle
(cid:1) <expr2> est évaluée avant chaque passage de la boucle. Elle est utilisée pour
décider si la boucle est répétée ou non.
(cid:1) <expr3> est évaluée à la fin de chaque passage de la boucle. Elle est utilisée pour
réinitialiser les données de la boucle.
En pratique, les parties <expr1> et <expr2> contiennent souvent plusieurs initialisations ou
réinitialisations, séparées par des virgules.
Exemple
Ecrire un programme qui affiche 5 fois le mot bonjour
void main()
Publicité
{
int i;
for (i=1; i<=5; i++)
{
printf(« bonjour »);
printf(« %d fois \n», i);
}
printf (« la valeur de i est %d », i) ;
}
Exécution
Bonjour 1 fois
Bonjour 2 fois
Bonjour 3 fois
Bonjour 4 fois
Bonjour 5 fois
la valeur de i est 6
Remarques :
for (i=0, j=0, k=0 ; …. ; …..)
est équivalent à
i=0; j=0;
Mme Wiem Yaiche Elleuch chapitre 4
9
for (k=0 ; … ; ….)
est équivalent à
i=0; j=0; k=0;
for ( ; …; …)
Exemple :
i=1;
for (; i<=5; i++)
{
printf(« bonjour »);
printf(« %d fois \n», i);
}
}
i=1;
for (; i<=5;)
{
printf(« bonjour »);
printf(« %d fois \n», i);
i++
}
}
Exemple :
Ecrire un programme qui calcule la somme des entiers de 1 à 100.
#include<stdio.h>
void main()
{
int n, som;
for (som=0, n=1 ; n<101 ; n++)
{
som+=n;
}
printf("La somme des nombres de 1 à 100 est %d\n", som);
}
Remarque :
La boucle for contient une seule instruction : som+=n; les accolades sont facultatives
#include<stdio.h>
void main()
{
int n, som;
for (som=0, n=1 ; n<101 ; n++)
som+=n;
printf("La somme des nombres de 1 à 100 est %d\n", som);
}
Choix de la structure répétitive
(cid:1) Si le bloc d'instructions ne doit pas être exécuté si la condition est fausse, alors utilisez
while ou for.
(cid:1) Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez do - while.
Mme Wiem Yaiche Elleuch chapitre 4
10
Break: sert à interrompre le déroulement de la boucle, en passant à l’instruction qui suit
cette boucle.
#include<stdio.h>
void main()
{
int i;
for (i=1 ; i<10; i++)
{
printf("bonjour \n");
if (i==3) break;
}
printf("fin du travail");
}
Exécution :
bonjour
bonjour
bonjour
fin du travail
Mme Wiem Yaiche Elleuch chapitre 4
11