"lesdeveloppeurs.net": Langage C : LES BOUCLES (Cours et Exercices corrigés)

-----------------L'INSTRUCTION SI ... ALORS ... SINON ...--------------


Il s'agit de l'instruction:
si (expression conditionnelle vraie)
alors {BLOC 1 D'INSTRUCTIONS}
sinon {BLOC 2 D'INSTRUCTIONS}

Organigramme:

Syntaxe en C:
if (expression)
{
............;/* bloc 1 d'instructions */
............;
............;
}
else
{
............;/* bloc 2 d'instructions */
............;
............;
}

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 nécessaires lorsque les blocs ne comportent qu'une seule instruction.

                                LES OPERATEURS LOGIQUES


test d'égalité:if (a==b)   " si a égal b "

test de non égalité:if (a!=b)   " si a différent de b "

tests de relation d'ordre:if (a<b)   if (a<=b)  if (a>b)  if (a>=b)

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 

test de NON LOGIQUEif (!(expression1))
" si l'expression1 est fausse "

Toutes les combinaisons sont possibles entre ces tests.

Exercice III-1: L'utilisateur saisit un caractère, le programme teste s'il s'agit d'une lettre majuscule, si oui il renvoie cette lettre en minuscule, sinon il renvoie un message d'erreur.


Le langage C admet des écritures contractées dans les expressions de test:

char reponse;                      est équivalent à     char reponse;
printf("Voulez-vous jouer ?");                          printf("Voulez-vous jouer ?");
reponse = getchar();
if(reponse == 'o')                                      if((reponse = getchar()) =='o')
printf("BONJOUR\n");                                    printf("BONJOUR\n");
else printf("TANT-PIS"\n);                              else printf("TANT-PIS"\n);

LA BOUCLE TANT QUE ... FAIRE ...


Il s'agit de l'instruction:

tant que (expression vraie)
faire{BLOC D'INSTRUCTIONS} 

Organigramme:

Syntaxe en C:
while (expression)
{
............;/* bloc d'instructions */
............;
............;
}

Le test se fait d'abord, le bloc d'instructions n'est pas forcément exécuté.

Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.

Remarque: On peut rencontrer la construction suivante: while (expression); terminée par un  et sans la présence du bloc d'instructions. Cette construction signifie: "tant que l'expression est vraie attendre".

                            L'INSTRUCTION POUR ...


Il s'agit de l'instruction:

pour (initialisation; condition de continuité vraie;modification)
{BLOC D'INSTRUCTIONS} 

Organigramme:

Syntaxe en C:

for(initialisation  condition de continuité  modification)
{
............;/* bloc d'instructions */
............;
............;
}

Remarques: 
Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.
Les 3 instructions du for ne portent pas forcément sur la même variable.
Une  instruction peut être omise, mais pas les 


Exemples:
for(i = 0  i<10  i++)
{
............;/* bloc d'instructions */
............;
............;
}

correspond à l'organigramme suivant:

La boucle
for(;;)
{
............;/* bloc d'instructions */
............;
............;
}

est une boucle infinie (répétition infinie du bloc d'instructions).

Utilisation de variables différentes:

resultat = 0;
for(i = 0  resultat<30  i++)
{
............;/* bloc d'instructions */
............;
............;
resultat = resultat + 2*i;
}

Exercice III-2:

Saisir un entier, calculer n!
Utiliser une boucle while puis une boucle for.
Quelle est la plus grande valeur possible de n, si n est déclaré int, puis unsigned ?

                               L'INSTRUCTION AU CAS OU ... FAIRE ...


L'instruction switch permet des choix multiples uniquement sur des entiers (int) ou des caractères (char).

Syntaxe:

switch(variable de type char ou int)au cas où la variable vaut:
{
case  valeur1: ......;          - cette valeur1: executer ce bloc d'instructions.
.......;
break;
           valeur2:........;               - cette valeur2:  executer ce bloc d'instructions.
 ........;
 break;
.
.etc ...
.
       default:  .......;                - aucune des valeurs précédentes: executer ce bloc
          ........;            d'instructions, pas de "break" ici.
 
}

le bloc "default" n'est pas obligatoire.

L’instruction switch correspond à une cascade d’instructions if ...else

Exemple:
Cette instruction est commode pour fabriquer des "menus":

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;

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

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

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

                          L'INSTRUCTION REPETER ... TANT QUE ...



Il s'agit de l'instruction:répéter{BLOC D'INSTRUCTIONS} 
tant que (expression vraie)


Organigramme: 

Syntaxe en C:
do
{
............;/* bloc d'instructions */
............;
............;
}
while (expression);

Le test se faisant après, le bloc est exécuté au moins une fois.

Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.

COMPLEMENT SUR LES TESTS


En langage C, une expression nulle de type entier (int) est fausse, une expression non nulle de type entier (int) est vraie.

Exemples:

int a,b,c,delta;                est équivalent à        int a,b,c,delta;
delta = b*b-4*a*c;                                      delta = b*b-4*a*c;
if(delta != 0)                                          if(delta)
{ ....... }                                             { ....... }


int a,b,c,delta;                est équivalent à        int a,b,c,delta;
delta = b*b-4*a*c;                                      delta = b*b-4*a*c;
if(delta == 0)                                          if(!delta)
{ ....... }                                             {.......}

                             EXERCICES RECAPITULATIFS


Exercice III_3: résoudre ax2 + bx +c = 0.

Exercice III_4: Saisir une suite de caractères, compter et afficher le nombre de lettres e et d'espaces. Utiliser les propriétés du tampon.

Exercice III_5: La fonction kbhit appartient à la bibiothèque conio.h. Une fonction équivalente peut exister avec d'autres compilateurs. La fonction kbhit teste si un caractère a été frappé au clavier. Tant que ce n'est pas vrai kbhit renvoie 0 (ceci signifie que la valeur de la fonction kbhit est 0).

Exemple: while(kbhit() == 0)/*tant qu'aucun caractère n'a été frappé exécuter la boucle*/
{ ..... }

Cette écriture est équivalente à:
 while(!kbhit()); /* tant que kbhit est faux,  exécuter la boucle */
{ ..... }

Ecrire un programme qui affiche le carré des entiers 1, 2, 3 ......, toutes les 500 ms tant qu'aucun caractère n'a été frappé au clavier. Générer la temporisation à l’aide d’une boucle for et d’un décompteur.

CORRIGE DES EXERCICES


Exercice III-1:

#include <stdio.h>
#include<conio.h>
void main()
{
char c;
printf("ENTRER UNE LETTRE:");
c = getchar();
if((c>='A') && (c<='Z')) printf("CETTE LETTRE EN MINUSCULE: %c\n",c);
else printf("CE N'EST PAS UNE LETTRE MAJUSCULE\n");
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

Exercice III-2:

#include <stdio.h>
#include <conio.h>
void main()
{
int n,i,fac= 1;
printf("ENTRER UN ENTIER: ");scanf("%d",&n);
for (i=1;i<=n;i++) fac= fac * i;
printf("\nn = %d  n! = %d",n,fac);
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE");
getch();
}

 Les entiers sont des nombres de 32 bits:
n int: n! maximum= 12!
n unsigned: n! maximum = 12!

Exercice III_3: 

#include <stdio.h>
#include <conio.h>
#include <math.h>/* contient la fonction racine */ 
void main()
 {
 float a,b,c,delta,x1,x2;
 /* saisie de A,B,C */
 printf("\t\t\tRESOLUTION DE L'EQUATION DU SECOND DEGRE\n");
 printf("\t\t\t               2\n");
 printf("\t\t\t             AX +BX+C=0\n\n\n");
 printf("SAISIR A B C SEPARES PAR RETURN\n");
 printf("A = ");scanf("%f",&a);
 printf("B = ");scanf("%f",&b);
 printf("C = ");scanf("%f",&c); 

 /* debut du calcul */
 /* cas particuliers */
 if((a==0)&&(b==0)&&(c==0))printf("INFINITE DE SOLUTIONS\n");
 if((a==0)&&(b==0)&&(c!=0))printf("PAS DE SOLUTIONS\n");
 if((a==0)&&(b!=0))printf("UNE SOLUTION: X= %f\n",-c/b);
 
 /*cas general */
 if(a!=0)
 {
 delta = b*b-4*a*c;
 printf("DELTA= %f\n",delta);
 if(delta<0)printf("DELTA NEGATIF PAS DE SOLUTION\n");
 else
 {
 if(delta==0)printf("DELTA NUL, UNE SOLUTION X= %f\n",-b/2/a);
else

{
 x1= (-b+sqrt(delta))/2/a;
 x2= (-b-sqrt(delta))/2/a;
 printf("DELTA POSITIF DEUX SOLUTIONS\n");
 printf("X1= %f  X2= %f\n",x1,x2);
 }
 }
 }
 
 /* calculs termines */
 printf("\n\nPOUR CONTINUER FRAPPER UNE TOUCHE");
 getch();
 }

Exercice III_4:

#include <stdio.h>
#include <conio.h>
void main()
{
char c,compt_espace= 0,compt_e= 0;
printf("ENTRER UNE PHRASE:\n");/* l'utilisateur saisit la totalite de sa phrase */

while((c=getchar())!='\n')     /* lors du 1er passage, getchar ne prend */
       /* en compte que le 1er caractere */
{                      /* les autres sont ranges dans le tampon */
if(c=='e')compt_e++;   /* et recuperes par getchar lors */ 
/* des autres passages */
if(c==' ')compt_espace++;
}

printf("NOMBRE DE e: %d\n",compt_e);
printf("NOMBRE D'ESPACE: %d\n",compt_espace);
printf("POUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}

Exercice III_5:

#include <stdio.h>
#include <conio.h>
void main()
{
int i = 0;
float x,tempo=5000000;
printf("POUR SORTIR DE CE PROGRAMME FRAPPER UNE TOUCHE ...\n");
do
{
printf("i = %d i*i = %d\n",i,i*i);
for(x=tempo;x>0;x--);
i++;
}
while(kbhit()==0);      /* on peut aussi ‚crire while(!kbhit()); */

Voici les exécutables

EXIII_1.CPP

EXIII_2.CPP

EXIII_3.CPP

EXIII_4.CPP

EXIII_5.CPP