La programmation C : cours 5




Nous allons finir pour ce cours-ci les structures de contrôle et l'algèbre de Bool. Dernière étape avant la programmation modulaire.


l'instruction do-while


L'instruction do-while permet, tout comme 'while' de répéter un bloc d'instruction tant qu'une condition n'est pas vraie (c'est à dire différente de 0). 


do {
  //instructions
} while (condition);


Ainsi nous pourrions écrire : 


do

   c=getchar();

while(c != 'o');


ou plus simplement :


do;
while( (c = getchar()) != 'o');


L'interêt de ce type de boucle par rapport à la boucle while est que le bloc d'instruction est éxécuté avant la vérification de la condition.


l'instruction for


Cette instruction tout comme 'while' et 'do-while' est une itération (structure répétitive)
Le principe est simple : on donne à cette structure trois "éléments" :
une instruction qui sera évaluée avant l'entrée dans la boucle, une instruction dont la valeur conditionnera la poursuite de la boucle (celle-ci etant evaluée à chaque nouveau passage), et une instruction lue à chaque fin d'une boucle. 


for (instruction1 ; instruction2 ; instruction3)
   //bloc d'instruction


Voici quelques exemples : 


//increment de la boucle
int increment;

//pour tout les increment jusqu'a 9 faire...
for (increment = 0 ; increment < 10 ; increment++)
{
	//...afficher le numero de boucle
	printf("boucle numero %d\n", increment);
}


mais aussi des boucles du genre:


for (i=0, j = 5, k = 2 ; printf("boucle %d\n", i), j > -5 ; i++, j-- , k+=10) ;


On peut ainsi décomposer chacune des trois instructions qui compose la boucle 'for', en plusieurs instructions qui seront séparées par une virgule.


les instructions break, continue et goto


L'instruction break interrompt le déroulement d'un bloc, en sautant celui-ci et en passant à l'instruction suivante.
exemple : 


for (int increment = 0 ; increment < 10 ; increment++)
{
	//...afficher le numero de boucle
	printf("boucle numero %d\n", increment);
	if (increment == 6) break;
}
printf("fin de la boucle\n");


ce qui donne en sortie :


boucle numero 0
boucle numero 1
boucle numero 2
boucle numero 3
boucle numero 4
boucle numero 5
boucle numero 6
fin de la boucle





nos programmes commencent à devenir de plus en plus complexes ...


L'instruction 'continue' passe directement à la boucle suivante
ainsi : 


for (int increment = 5 ; increment > 0 ; increment--)
{
	//...afficher le numero de boucle
	if (increment = 3) continue;
	printf("boucle numero %d\n", increment);
}
printf("fin de la boucle\n");


donne la sortie :


boucle numero 5
boucle numero 4
boucle numero 2
boucle numero 1
fin de la boucle


'goto' sert principalement à sortir de structures de contrôle imbriquées. L'utiliser dans un autre but est souvent synonyme de mauvaise programmation ; on peut souvent s'en passer.
Elle permet de se "brancher" à un endroit précis du programme : 


if (condition)
  goto label;

//instructions diverses

//etiquette de branchement
label : 
//instructions


Un exemple sera plus clair : 


for (increment = 0 ; increment  < 10 ; increment++)
	while (increment2++ < 10)
	{
		if (increment == 5) goto etiquette;
    }	            

etiquette :
printf("on est sorti des deux boucles\n");


l'instruction switch


Maintenant que nous connaissons 'break' nous pouvons aborder l'instruction 'switch'.
Commençons par un exemple : 


scanf("%d", &entier);

switch (entier)
{
case 0 : printf("c'est le nombre 0 !!\n");
	   break;
case 1 : printf("c'est le nombre 1 !!\n");
	   break;
case 2 : printf("c'est le nombre 2 !!\n");
         break;
default : printf("trop grand !!\n");
}


Nous demandons ici à l'utilisateur d'entrer un entier. 'switch' evalue alors la valeur de ce nombre, et la compare avec les constantes des différents 'case'. Si cette valeur correspond, alors il exécute les instructions qui suivent le 'case', jusqu'à ce qu'il rencontre la fin du bloc, ou un break. Si ce nombre n'est pas trouvé, il exécute les instructions se trouvant après le 'default', ou si il n'y a pas de 'default' sort directement.
Ainsi, si entier vaut 0 on aura la sortie suivante :


c'est le nombre 0 !!


si on entre le nombre 8 nous aurons :


trop grand !!


à la sortie.
Voici un exemple de 'switch' où on a omis certains 'break' : 


scanf(%d", &entier);

switch (entier)
{
case 0 : printf ("ce nombre ne vaut rien!\n");
	   break;
case 1 : 
case 2 :
case 3 : printf ("c'est un petit nombre\n");
	   break;

case 4 : 
case 5 :
case 6 : 
case 7 :printf ("c'est un grand nombre\n");
	  break;
default : printf ("négatif ou >8!!\n");
}


Si on entre alors le nombre '1' nous aurons la sortie "c'est un petit nombre", car le programme a exécuté toutes les instructions qu'il trouvait après 'case 1:', jusqu'à ce qu'il rencontre un 'break'.
On ne peut mettre à coté d'un 'case' qu'une constante ou une expression constante, c'est souvent source d'erreurs incompréhensibles ('3', est une constante, '3+5' est une expression constante, et enfin toute déclaration faite avec le mot clé 'const' est valable)


Suite et fin de l'algèbre de bool.


Comment pouvons-nous faire pour évaluer deux expressions (par exemple 'a < b' et 'c == d')en même temps ?
Nous pourrions dans le cas d'un 'if' faire : 


//si a est inferieur a b...
if (a < b)
  {
	//...et si c est égal à d
	if (c == d)
	  //instruction1
	//...et si c est different de d
	else
	  //instruction2
  }
//...sinon
else
   instruction3


Mais c'est un code avec beaucoup de redondance. Nous préférons l'opérateur logique '&&'.
L'expression


(a < b) && (c == d)


prend la valeur vrai (1) si les deux conditions (a < b) et (c == d) sont toutes deux vraies (égales à 1), sinon dans tous les cas prend la valeur 0 (faux).
De même, nous avons l'opérateur '||', qui prend la valeur 'faux' si les deux conditions sont égales à 0, et 'vrai' si l'une d'(entre elles ou les deux sont vraies.
'&&' est dit 'et' logique, et '||' et dit 'ou' logique.
Enfin pour finir l'opérateur '!' inverse la valeur d'une condition ; si (c == d) vaut 1 (vrai) par exemple, alors !(c == d) sera fausse (0).


Nous aborderons dans le cours suivant le linkage, la programmation modulaire afin de savoir créer plusieurs fonctions au sein d'un même programme, et le préprocesseur.
D'ici-là nous ne pouvons que vous souhaiter une bonne programmation !


Annexe


(Condition 1)   Opérateur   (Condition 2)
 résultat
0 && 0
 0
0 && 1
 0
1 && 0
 0
1 && 1
 1
0 || 0
 0
0 || 1
 1
1 || 0
 1
1 || 1
 1
   ! 0
 1
   ! 1
 0


[  Précédent  |  Index  |  Suivant  ]


par Valentin BILLOTTE