CH 2 - Les Instruction en Langage C

Enseignant : Mohamed Bécha Kaâniche
Module : Langage C – Programmation C

Année Universitaire : 2011-2012
Chapitre 2 : Les instructions en langage C

1. Introduction
Une instruction en langage C peut désigner :
 une instruction simple : elle peut être

 une instruction nulle,
 une instruction d’affectation,
 ou un appel de fonction.
 une instruction composée : elle est défini par une structure de contrôle qui peut être
 une instruction de choix conditionnelle (ou de sélection),
 une instruction de répétition,
 ou une instruction de ruptures de séquences.
 un groupe d’instructions : il constitue un bloc d’instructions placées entre accolades « {…} ».
Remarques importantes :
 le symbole « ; » et un terminateur d’instruction simple et non pas un séparateur comme

dans Pascal et dans les langages semblables. Ainsi, il n’apparaît jamais après l’accolade
fermante d’un bloc d’instructions. La présence de ce terminateur est spécifiée au niveau de
la description syntaxique de chaque instruction simple.
 Les accolades « { » et « } » servent à regrouper des déclarations et des instructions pour
obtenir une instruction composée, ou bloc, qui est toujours syntaxiquement équivalent à une
instruction unique. L’accolade fermante « } » qui termine un bloc n’est pas suivie d’un point
virgule.
 Un bloc comprend éventuellement, au début, une partie déclarative. Les variables déclarées
dans les blocs portent le nom de variables internes. Elles sont utilisables (visibles),
uniquement dans le bloc où elles ont été déclarées. Le corps d’une fonction (délimité par des
accolades) constitue un bloc.
2. Les instructions simples

2.1. L’instruction nulle
Syntaxe :
;
2.2. L’instruction d’affectation

Syntaxe :
<variable> = <expression> ;
Le symbole d’affectation est le caractère « = ». Une expression peut représenter une constante,
une variable, une expression arithmétique ou logique, une expression relationnelle ou une fonction
retournant une valeur. L’expression est évaluée et fournit une valeur qui est placé dans la variable
1 Chapitre 2 : Les instructions en langage C

spécifié à gauche du symbole d’affectation. Une conversion vers le type de la variable réceptrice
peut intervenir lorsque les types sont différents.
2.3. Appel de fonction

Une instruction simple peut être un appel de fonction. C’est dans le cas où l’appel de fonction ne
nécessite pas d’affectation (éventuellement, une fonction au sens procédure de Pascal) :
calculer(truc) ;
3. Les instructions composées

3.1. L’instruction de choix conditionnelle
Cette instruction permet d’exprimer: l’exécution conditionnelle :
si (expression_logique) alors ...
ou l’alternative :
si (expression_logique) alors ...sinon ....
Comme il n’y pas de type booléen en C, « expression_logique » est en fait une expression qui doit
avoir une valeur numérique (réelle, ou de préférence entière). La forme standard est d’utiliser le
mot-clé « if » avec ou sans partie « else ». La syntaxe est la suivante, chacune de ces constructions
est une instruction :
Syntaxe :
if (expression_logique) /* Notez qu’il n’y a pas de mot-cle then en C */
<instruction ou bloc d’instructions>
ou
if (expression_logique)
else
Des exemples :
if (i==j) /*if avec… */
z = calculer_1(x,y) ;
else /*…partie else*/
……
if (z>x) { /* if sans partie else */
……
}
En cas de constructions « if » imbriquées, le « else » se rattache toujours au « if » le plus proche qui

n’a pas déjà de partie « else ». Par exemple :
if (i==j) /*premier if (sans else)*/
if (k==j) /*deuxieme if (avec else)*/
else /*else du deuxieme if*/
……

Dans l’exemple précédent, si le « else » doit être rattaché au premier « if », il faut obligatoirement
utiliser des délimiteurs de blocs:
if (i==j){ /*premier if (avec else)*/
if (k==j) /*deuxieme if (sans else)*/
} else /*else du premier if*/
……
Enfin, il existe une autre forme de conditionnelle. Il s’agit d’une expression et non d’une
instruction. Celle-ci possède donc une valeur (à retourner).
expression_logique ? expression_1 : expression_2
L’expression précédente prend la valeur « expression_1 » si « expression_logique » est vrai, et la

valeur « expression_2 » sinon. L’instruction suivante utilise cette expression conditionnelle :
x = (i>j) ? y+z : y-z ;
et elle est équivalente à l’instruction:
if (i>j)
x = y+z ;
else
x = y–z ;
Remarques :
 Éviter ce genre d’expression, certes concise, mais peu lisible.
3.2. L’instruction de sélection

L’instruction de sélection s’exprime en langage C par l’instruction « switch »:
switch (expression) {
case valeur_1:
break;
case valeur_2:
break;
……
case valeur_n:
break;
default:
}
L’ « expression » peut être de type entier, caractère ou d’un type énuméré (voir chapitre 4). Les
valeurs: « valeur_1 », « valeur_2 », ... sont des constantes ou des expressions du même type. On
peut avoir plusieurs instructions après chaque case. Les délimiteurs de blocs ne sont utiles que si
l’on déclare des variables locales. La dernière instruction dans un case est souvent l’instruction
« break; » qui sert à sortir de la construction « switch ». Si l’on omet « break; » les instructions du
(ou des) « case(s) » qui suivent le « case » sélectionné seraient aussi exécutées.
La partie « default » est optionnelle, si elle existe, elle sera sélectionnée si aucun « case » ne
convient. Les instructions « case » ne définissent que des « points d’entrée ». On s’arrête à la
première instruction break rencontrée. Attention aux oublis !
Si la variable de contrôle est de type énuméré, il est possible de prévoir une entrée « case » pour
chacune des valeurs possibles. En revanche, si la variable qui commande le choix est de type entier,
il est prudent de prévoir une partie « default » pour être sûr de traiter tous les cas:
…
int nb ;
…
switch (nb) {
case 0:
x = 0.0 ;
break;
case -2:
y /= 2 ;
case -1:
x = y – z ;
break;
case +2:
y *= 2 ;
case +1:
x = y + z ;
break;
case -3:
case +3:
break;
default:
{
/*variables locales*/
double yLoc,zLoc;
/*actions en consequences*/
……
} /*fin du bloc default*/
} /* fin du switch */
Attention :
 Une erreur courante et parfois difficilement détectable consiste à oublier une

instruction « break; ».
Remarques :
 Le choix « default », s’il existe, peut être mis n’importe où dans la liste. Il est plus clair de le
faire figurer en dernier.
 L’instruction « break; » du dernier choix n’est pas nécessaire. Sa présence n’est pas une
erreur et peut permettre d’en éviter par la suite si l’on doit modifier le programme.
 L’instruction « switch » s’utilise souvent en relation avec des types énumérés. Les mêmes
réserves s’appliquent; utiliser un type énuméré revient à figer une fois pour toutes un certain
nombre de choix, limitant ainsi les possibilités d’évolutions du logiciel.

3.3. Les instructions de répétition

Pour exprimer la répétition, le langage C offre trois possibilités de constructions appelées boucles.
On appelle corps de boucle l’instruction (simple ou bloc) dont l’exécution sera répétée.
3.3.1. La boucle tant que

La boucle tant que suit syntaxe suivante:
while (expression_logique)
<instruction ou bloc d’instructions> /* corps de boucle */
Dans cette construction, le corps de boucle est exécuté tant que l’expression logique est vrai et
donc éventuellement zéro fois. « expression_logique » doit être de type numérique, de
préférence entier.
int encore ;
……
while (encore) {
calculer(x,y,z) ;
……
encore = …… ;
}
3.3.2. La boucle répéter « tant que »

Il s’agit d’une variante de la boucle tant que, sa syntaxe est la suivante:
do
while (expression_logique)
avec « expression_logique » de type numérique, de préférence entier. Dans cette deuxième

construction, le corps de la boucle est toujours exécuté au moins une fois puisque le test est
effectué à la fin;
double x,y ;
x=0.0 ;
y = 1000.0 ;
……
do
mise_a_jour(x,y) ; /* au moins une fois */
while (x <= y)
3.3.3. La boucle Pour

La boucle pour suit la syntaxe suivante:
for (<expr_initiale> ;<expr_test_arret> ;<expr_mise_a_jour>)

Dans la parenthèse qui suit le mot-clef « for », la première expression représente la valeur initiale
du compteur ou du paramètre de la boucle, la seconde le test d’arrêt et la troisième
l’incrémentation ou la mise à jour du paramètre. La variable qui sert de compteur n’est pas locale
à la boucle, elle doit donc être déclarée dans un bloc englobant. La forme la plus courante est la
boucle for avec un compteur entier qui se code comme suit:

int i ;
……
for (i=0; i<n; i++)
Remarques :
 Le corps de boucle peut être exécuté zéro fois.
 L’équivalent de la boucle « pour » en utilisant la construction « while » est :
<expr_initiale> ;
while (<expr_test_arret>) {
<expr_mise_a_jour> ;
}
 Dans la syntaxe du « for », toutes les expressions sont optionnelles. Ainsi (à l’extrême):
for (;;)
est une boucle infinie. Plus généralement, on omet un ou plusieurs terme(s) si le
compteur est modifié dans le corps de boucle, mais cette façon de programmer ne
semble pas recommandable.
3.4. Les ruptures de séquence

Dans chacune des constructions « for », « while » et « do ...while », on peut utiliser dans le corps
de boucle les deux instructions suivantes:
 continue;
Cette instruction interrompt l’exécution du corps de boucle. On reprend donc l’exécution
du programme au début du corps de boucle, si la valeur suivante du compteur ou de la
condition le permet, sinon après la boucle. Dans le cas de la boucle for, l’expression de
mise à jour est tout de même exécutée.
 break;
Cette instruction interrompt l’exécution de la boucle. On reprend donc l’exécution du
programme après la boucle.
Voici un exemple:
for (i=0; i<n; i++) {
calculer_1(x,y,z) ;
if(x>0.0) {
……
continue; /* je passe directement au i suivant*/
} /*fin if*/
calculer_2(x,y,z) ;
if(y<0.0)
break; /* j’arrete et je sors de la boucle */
……
} /*fin for*/

Dans le cas où des boucles « for », « while » ou « do...while » sont imbriquées, les ruptures de
séquences « continue » et « break » ne s’adressent qu’à la boucle la plus interne.
Les constructions précédentes (condition, sélection, répétition) servent à structurer le code. Les
débranchements inconditionnels ne sont donc pas nécessaires; la seule «bonne» utilisation serait
de simuler ces constructions dans des langages où elles n’existent pas (notamment FORTRAN). Il
existe néanmoins, en langage C une troisième rupture de séquence « goto » effectuant un
débranchement inconditionnels:
……
goto Etiquette
……
……
Etiquette :
……
……
dont l’usage, bien sûr, n’est pas conseillé.
Annexe A – Travaux pratiques n°2
Exercice n°1
Ecrire un programme qui saisit deux entier et indique s’ils sont égaux ou pas et affiche le plus petit.
Exercice n°2
Ecrire un programme qui saisit un caractère alphabétique et indique si celui-ci est une voyelle ou une
consonne et s’il s’agit d’une majuscule ou non. Vous utiliserez la table du code ASCII.
Exercice n°3
Ecrire un programme qui lit successivement : un nombre (<nombre1>), un opérateur (+,-,*,/) et un
nombre (<nombre2>) et qui retourne le résultat de l’opération: <nombre1> <operateur> <nombre2>,
puis propose d’arrêter ou de refaire le calcul.
Exercice n°4
Parmi tous les entiers supérieurs à 1 et inférieurs à 500, il y en a seulement 4 qui peuvent être
représentés par la somme des cubes de leur chiffre (xyz = x3 + y3 + z3).
Ecrire un programme qui détermine ces 4 nombres.
Exercice n°5
La fonction rand retourne un entier compris entre 0 et RAND_MAX de manière aléatoire. La
constante RAND_MAX ainsi que le prototype de la fonction rand sont définis dans le fichier stdio.h.
Ecrire un programme qui initialise de manière aléatoire un entier entre 0 et 100 et propose de le
faire deviner à l’utilisateur. Pour ce faire, à chaque tentative de l’utilisateur, le programme lui indique
si sa proposition est plus petite ou plus grande que la valeur de l’entier recherché.

Annexe B – Les fonctions d’entrées/sorties classiques

Il s’agit de fonctions de la bibliothèque standard utilisée avec les unités classiques d’entrées/sorties,
ces unités étant généralement le clavier et l’écran ou l’imprimante.
B.1. Les fonctions d’entrées/sorties non formatées

« Non formatée » signifie que les données ne subiront pas de conversion lors d’une opération de
lecture ou d’écriture. Les seuls types de données susceptibles d’être traitées par ces fonctions sont
les caractères ou les chaînes de caractères. Toutes ces fonctions sont définies dans le fichier « en-
tête » « stdio.h ».
B.1.1. La lecture
a) Lecture d’un caractère

Syntaxe :
C = getchar() ;
La fonction getchar() retourne une valeur de type « int » représentant normalement le caractère
lu. En cas de fin de fichier ou d’erreur elle retourne la valeur EOF (voir chapitre 7).
b) Lecture d’une chaine de caractères

Syntaxe :
gets(s) ;
« s » est le nom d’un tableau (ou d’un pointeur vers un tableau), tableau déclaré
antérieurement, qui recevra la chaine de caractères lue.
B.1.2. L’écriture
a) Ecriture d’un caractère

Syntaxe :
putchar(c) ;
La fonction putchar(c) retourne une valeur de type « int » représentant normalement le

caractère écrit. En cas d’erreur, elle retourne la valeur EOF (voir chapitre 7).
b) Ecriture d’une chaîne de caractères

Syntaxe :
puts(s) ;
« s » est le nom d’un tableau qui contient la chaine de caractères. De façon plus général, « s »
peut être un pointeur vers une chaîne de caractères ou la chaîne elle-même. La fonction
« puts(s) » retourne une valeur de type « int ». Elle provoque automatiquement un retour à la
ligne après l’édition de la chaîne de caractères. C’est donc le caractère ‘\0’ final qui est
transformé automatiquement en ‘\n’.

B.2. Les fonctions d’entrées/sorties formatées

Les données lues, ou à imprimer, seront converties selon le format particulier choisi. On distingue
les deux fonctions :
Syntaxe :
scanf("format",arg1,arg2,…,argn) ; /* pour la lecture des donnees */
printf("format",agr1,arg2,…,argn) ; /* pour l’ecriture des donnees*/
« format » représente la zone de contrôle. Cette zone est suivie d’un ou plusieurs arguments (nom
de variables ou expressions).
La liste des caractères de conversions standards sont :
Caractère Description
d, i Conversion en entier signé en base décimal. '%d' et '%i' sont synonymes pour
printf() mais different avec scanf() : '%i' prend en compte la lecture d’entier en
notation octal ou hexadécimal ce qui n’est pas le cas pour '%d'.
u Conversion en entier non signé (unsigned int).
f, F Conversion en « float » en notation à point fixe (mm.nn). 'F' n’est pas pris en
charge par scanf(). Dans le cas de printf(), 'f' et 'F' diffèrent seulement dans la
manière dont les nombres infinis ou impossible (not a number) sont affichés ('inf',
'infinity' et 'nan' pour 'f', 'INF', 'INFINITY' et 'NAN' pour 'F').
e, E Conversion en « float » en notation avec exposant (ç.à.d. [-]mm.nnne[+/-]xxx ). La
conversion ‘%E’ utilise la lettre ‘E’ (plutôt que ‘e’) pour introduire l‘exposant.
L’exposant contient au moins deux chiffres ; Si la valeur est zéro, alors l’exposant
est “00”.
g, G Conversion en « float » en notation à point fixe ou en notation avec exposant selon
la magnitude du nombre. 'g' utilise les lettres minuscules tandis que 'G' utilise les
lettres majuscules.
x, X Conversion en entier non signé en hexadécimal. 'x' utilise des lettres minuscules
(‘a’..’f’) tandis que 'X' utilise des lettres majuscules (‘A’..’F’).
o Conversion en entier non signé en octal.
s Conversion en chaîne de caractères terminés par le caractère « null ».
c Conversion en caractère (char).
p Seulement pour printf(). Conversion en « void * » (pointeur à void) : format définie
par l’implémentation.
% Le littéral '%' ne réalise aucune affectation pour scanf() et imprime le caractère ‘%’
dans le cas de printf() sans aucune conversion.
Exemple :
 printf("la somme = %d",s) ;
 scanf("%2d%*s%2d%*s%2d%*s",&hr,&mn,&sec);
Si ‘*’ suit ‘%’ alors la valeur ne sera pas affecté à l’argument. Celui-ci est sauté. L’entrée des
données du clavier pourrait se présenter sous la forme : « 17H 355 min 300 secondes », les
chaines de caractères seront alors ignorées et seulement les deux premiers chiffres de chaque
nombre sont pris en compte lors de la lecture.
Remarques :
 La longueur du type lu ou écrit peut être modifiée en la précédant par un modificateur de
conversions à savoir :
Caractère Description
hh Pour les conversions de types entiers (d, u, o, x), convertit un caractère non signé
(unsigned char) en tant qu’entier (code ascii).
h Pour les conversions de types entiers (d, u, o, x), conversion d’un entier court (short).
l Pour les conversions de types entiers (d, u, o, x), conversion d’un entier long (long).
Pour les conversions de type float (e, f, g), conversion d’un « double ».
ll Pour les conversions de types entiers (d, u, o, x), conversion d’un entier très long (long
long).
L Pour les conversions de type float (e, f, g), conversion d’un « long double ».
 D’autres options sont disponibles pour printf(), entre le ‘%’ et le caractère de conversion et
éventuellment le modificateur de conversion, on peut placer dans cet ordre:
o ‘-‘ : justification à gauche : un cadrage à gauche au lieur du cadrage par défaut à
droite.
o ‘+’ : toujours signé : imprime systématiquement le signe du nombre.
o Blanc (un et un seul espace) : pour les conversions numériques, si le premier
caractère n’est pas un signe, place un espace au début.
o ‘0’ (zéro) : pour les conversions numériques, il complète le début du champ réservé
par des zéros.
o Un nombre « n » : spécifie la largeur du champ : au moins « n » caractères sont
imprimés : précise le nombre minimum de caractères d’impression.
o Un point « . » : il sépare la largeur du champ de la précision désirée.
o Un nombre : la précision qui donne soit le nombre de caractères d’une chaîne à
imprimer, soit le nombre de chiffres à imprimer à droite du point décimal pour les
conversions « e, E, f, F », soit le nombre de chiffres significatifs pour les conversions
« g, G », soit le nombre minimum de chiffres à imprimer pour un entier.

Annexe C – La bibliothèque standard C
La bibliothèque standard de C est une collection normalisée d'en-têtes et de routines utilisées pour
implémenter des opérations courantes, telles que les entrées/sorties et la gestion des chaînes de
caractères, dans le langage C. Le nom et la signature (le « prototype » en C) de chaque fonction sont
décrits dans des fichiers « en-têtes », tandis que le code objet des fonctions est séparée dans une
bibliothèque logicielle, qui ne sera liée au reste du programme qu'au moment de l'édition de liens. La
bibliothèque standard était initialement fournie avec le compilateur, mais aujourd'hui elle fait
souvent partie du système d'exploitation.
En 1983 l'Institut national américain des standards (American National Standards Institute (ANSI)) a
formé un comité pour établir une spécification normalisée de C, connue sous le nom de « C ANSI ».
Ce travail culmina avec la création de la norme C89 en 1989. Une partie de la norme résultante était
un ensemble de fonctions de bibliothèque appelé bibliothèque standard C ANSI (ANSI C standard
library). Cette norme est devenue norme internationale en 1990, et est aussi connue comme C ISO
(ISO C).
Des révisions ultérieures de la norme C ISO ont ajouté de nouvelles fonctions et de nouveaux en-
têtes à la bibliothèque. Le support de ces extensions varie selon les implémentations. Les en-têtes
<iso646.h>, <wchar.h>, et <wctype.h> ont été ajoutés avec l'amendement normatif 1 (Normative
Amendment 1), abrégé ci-dessous par « Amd.1 », qui constitue un ajout à la norme C ratifiée en
1995. Les en-têtes <complex.h>, <fenv.h>, <inttypes.h>, <stdbool.h>, <stdint.h> et <tgmath.h> ont
été ajoutées avec le C99, une révision de la norme C publiée en 1999.
La bibliothèque standard C ISO consiste en 24 fichiers « en-têtes » qui peuvent être inclus dans un
projet de programmeur avec une simple directive. Chaque fichier « en-tête » contient des prototypes
de fonctions, des définitions de types et des macros. Le contenu de ces en-têtes est décrit ci-dessous.
<assert.h> <errno.h>
Contient la macro « assert », utilisée pour Ensemble (ou le plus souvent sous-ensemble)
aider à détecter des incohérences de données des codes d'erreurs renvoyés par les fonctions
et d'autres types de bogues dans les versions de la bibliothèque standard au travers de la
de débogage d'un programme. variable errno.
<complex.h> <fenv.h>
Pour manipuler les nombres complexes Pour contrôler l'environnement en virgule
(introduit par C99). flottante (floating-point) (introduit par C99).
<ctype.h> <float.h>
Fonctions utilisées pour classifier rapidement Contient des constantes qui spécifient les
les caractères, ou pour convertir entre propriétés des nombres en virgule flottante
majuscules et minuscules de manière qui dépendent de l'implémentation, telles que
indépendante du système de codage des la différence minimale entre deux nombres en
caractères) (character set) utilisé (ASCII, ISO virgule flottante différents (xxx_EPSILON), le
8859-1, EBCDIC, etc.). nombre maximum de chiffres de précision

(xxx_DIG) et l'intervalle des nombres pouvant <stddef.h>

être représentés (xxx_MIN, xxx_MAX). Définit plusieurs types et macros utiles,
comme NULL.
<inttypes.h>
Pour des conversions précises entre types <stdint.h>
entiers (introduit par C99). Définit divers types d'entiers, c'est un sous-
ensemble de inttypes.h (introduit par C99).
<iso646.h>
Pour programmer avec le jeu de caractères <stdio.h>
ISO 646 (introduit par Amd.1). Fournit les capacités centrales d'entrée/sortie
du langage C, comme la fonction printf.
<limits.h>
Contient des constantes qui spécifient les <stdlib.h>
propriétés des types entiers qui dépendent de Pour exécuter diverses opérations dont la
l'implémentation, comme les intervalles des conversion, la génération de nombres pseudo-
nombres pouvant être représentés (xxx_MIN, aléatoires, l'allocation de mémoire, le contrôle
xxx_MAX). de processus, la gestion de l'environnement et
des signaux, la recherche et le tri.
<locale.h>
Pour s'adapter aux différentes conventions <string.h>
culturelles. Pour manipuler les chaînes de caractères.
<math.h> <tgmath.h>
Pour calculer des fonctions mathématiques Pour des opérations mathématiques sur des
courantes. C99 a ajouté de nombreuses types génériques (introduit par C99).
fonctions mathématiques, en particulier pour
converger avec la norme CEI 559 dite aussi <time.h>
IEEE 754. Pour convertir entre différents formats de
date et d'heure.
<setjmp.h>
Pour exécuter des instructions goto non <wchar.h>
locales (sortes d'exceptions). Pour manipuler les caractères larges (wide
char), nécessaire pour supporter un grand
<signal.h> nombre de langues et singulièrement Unicode
Pour contrôler les signaux (conditions (introduit par Amd.1).
exceptionnelles demandant un traitement
immédiat, par exemple signal de l'utilisateur). <wctype.h>
Pour classifier les caractères larges (introduit
<stdarg.h> par Amd.1).
Pour créer des fonctions avec un nombre
variable d'arguments.
<stdbool.h>
Pour avoir une sorte de type booléen
(introduit par C99).

CH 2 - Les Instruction en Langage C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CH 2 - Les Instruction en Langage C

Transféré par

Droits d'auteur :

Formats disponibles

Enseignant : Mohamed Bécha Kaâniche

Module : Langage C – Programmation C

Chapitre 2 : Les instructions en langage C

 une instruction simple : elle peut être

 le symbole « ; » et un terminateur d’instruction simple et non pas un séparateur comme

2. Les instructions simples

2.2. L’instruction d’affectation

1 Chapitre 2 : Les instructions en langage C

2.3. Appel de fonction

3. Les instructions composées

En cas de constructions « if » imbriquées, le « else » se rattache toujours au « if » le plus proche qui

2 Chapitre 2 : Les instructions en langage C

L’expression précédente prend la valeur « expression_1 » si « expression_logique » est vrai, et la

et elle est équivalente à l’instruction:

 Éviter ce genre d’expression, certes concise, mais peu lisible.

3.2. L’instruction de sélection

 Une erreur courante et parfois difficilement détectable consiste à oublier une

4 Chapitre 2 : Les instructions en langage C

3.3. Les instructions de répétition

3.3.1. La boucle tant que

3.3.2. La boucle répéter « tant que »

avec « expression_logique » de type numérique, de préférence entier. Dans cette deuxième

3.3.3. La boucle Pour

for (<expr_initiale> ;<expr_test_arret> ;<expr_mise_a_jour>)

5 Chapitre 2 : Les instructions en langage C

3.4. Les ruptures de séquence

6 Chapitre 2 : Les instructions en langage C

dont l’usage, bien sûr, n’est pas conseillé.

Annexe A – Travaux pratiques n°2

Ecrire un programme qui détermine ces 4 nombres.

7 Chapitre 2 : Les instructions en langage C

Annexe B – Les fonctions d’entrées/sorties classiques

B.1. Les fonctions d’entrées/sorties non formatées

a) Lecture d’un caractère

b) Lecture d’une chaine de caractères

a) Ecriture d’un caractère

La fonction putchar(c) retourne une valeur de type « int » représentant normalement le

b) Ecriture d’une chaîne de caractères

8 Chapitre 2 : Les instructions en langage C

B.2. Les fonctions d’entrées/sorties formatées

10 Chapitre 2 : Les instructions en langage C

Annexe C – La bibliothèque standard C

11 Chapitre 2 : Les instructions en langage C

(xxx_DIG) et l'intervalle des nombres pouvant <stddef.h>

12 Chapitre 2 : Les instructions en langage C

Vous aimerez peut-être aussi