Le langage C Chapitre 7 : branchement conditionnel/non conditionnel et boucles

1.8 Les instructions de branchement
conditionnel


On appelle instruction de contrôle toute instruction qui
permet de contrôler le fonctionnement d'un programme. Parmi les instructions de
contrôle, on distingue les instructions de branchement et les boucles.
Les instructions de branchement permettent de déterminer quelles instructions
seront exécutées et dans quel ordre.


1.8.1 Branchement conditionnel if---else



La forme la plus générale est
celle-ci :


if (instruction-1 else if (instruction-2 ...else if (instruction-nelse expression ) instruction
peut être un bloc d'instructions.


1.8.2 Branchement multiple switch


Sa forme la plus générale est celle-ci :


switch (constante-1: constante-2: constante-n: liste d'instructions ¥ break; }

Si la valeur de constantes, la liste d'instructions ¥
correspondant à default est
exécutée. L'instruction default
est facultative.


1.9 Les boucles



Les boucles permettent de répéter une série
d'instructions tant qu'une certaine condition n'est pas vérifiée.


1.9.1 Boucle while



La syntaxe de while est la suivante :


while (expression
est vérifiée (i.e., non nulle), expression est
nulle au départ, instruction
peut évidemment être une instruction composée. Par exemple, le programme
suivant imprime les entiers de 1 à 9.


i = 1;while (i < 10) { printf("\n i = %d",i); i++; }

1.9.2 Boucle do---while



Il peut arriver que l'on ne
veuille effectuer le test de continuation qu'après avoir exécuté l'instruction.
Dans ce cas, on utilise la boucle do---while.
Sa syntaxe est


do expression );

Ici, expression
est non nulle. Cela signifie donc que expr 1 ;expr 3) expr 1; while (instruction etiquette correspondant. Elle est
à proscrire de tout programme C digne de ce nom.


1.11 Les fonctions d'entrées-sorties
classiques



Il s'agit des fonctions de la librairie standard stdio.h utilisées avec les unités
classiques d'entrées-sorties, qui sont respectivement le clavier et l'écran.
Sur certains compilateurs, l'appel à la librairie stdio.h par la directive au préprocesseur


#include

n'est pas nécessaire pour utiliser printf et scanf.



1.11.1 La fonction d'écriture printf



La fonction printf
est une fonction d'impression formatée, ce qui signifie que les données sont
converties selon le format particulier choisi. Sa syntaxe est


printf("expression-n);



La

argument-n

)


La

caractere

sur la
sortie standard :


retirer ce mot(caractere);



Elle retourne un int
correspondant à l'entier lu ou à la constante EOF
en cas d'erreur.

Par exemple, le programme suivant lit un fichier et le recopie caractère par
caractère à l'écran.


#include main(){ char c; while ((c = getchar()) != EOF) retirer ce mot(c);}

Pour l'exécuter, il suffit d'utiliser l'opérateur de
redirection d'Unix :
nom-fichier

Notons que l'expres​sion(c
= getchar()) dans le programme précédent a pour valeur la valeur de
l'expression getchar() qui est
de type int. Le test (c = getchar()) != EOF compare donc bien
deux objets de type int
(signés).

Ce n'est par contre pas le cas dans le programme suivant :


#include main(){ char c; do { c = getchar(); if (c != EOF) retirer ce mot(c); } while (c != EOF);}

Ici, le test c != EOF
compare un objet de type char et
la constante EOF qui vaut -1.
Si le type char est non signé
par défaut, cette condition est donc toujours vérifiée. Si le type char est signé, alors le caractère de
code 255, y, sera converti en l'entier -1. La rencontre du
caractère y sera donc interprétée comme une fin de fichier. Il est donc
recommandé de déclarer de type int
(et non char) une variable
destinée à recevoir un caractère lu par getchar
afin de permettre la détection de fin de fichier.


1.12 Les conventions d'écriture d'un
programme C



Il existe très peu de contraintes dans l'écriture d'un
programme C. Toutefois ne prendre aucune précaution aboutirait à des
programmes illisibles. Aussi existe-t-il un certain nombre de conventions.

• On n'écrit qu'une seule
  instruction par ligne : le point virgule d'une instruction ou d'une
  déclaration est toujours le dernier caractère de la ligne.
  
• Les instructions sont
  disposées de telle façon que la structure modulaire du programme soit mise
  en évidence. En particulier, une accolade ouvrante marquant le début d'un
  bloc doit être seule sur sa ligne ou placée à la fin d'une ligne. Une
  accolade fermante est toujours seule sur sa ligne.
  
• On laisse un blanc
  
  
  
  • entre les mots-clefs if, while,
    do, switch et la parenthèse ouvrante qui
    suit,
    
  • après une virgule,
    
  • de part et d'autre
    d'un opérateur binaire.
    
  </li>
  
• On ne met pas de blanc
  entre un opérateur unaire et son opérande, ni entre les deux caractères
  d'un opérateur d'affectation composée.
  
• Les instructions doivent
  être indentées afin que toutes les instructions d'un même bloc soient
  alignées. Le mieux est d'utiliser le mode C d'Emacs.