Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.

Otmane

-Lnom-de-répertoire : spécifie le répertoire dans lequel doivent être recherchées les librairies précompilées
(en plus du répertoire usuel).
1 Un peu d’histoire -o nom-de-fichier : spécifie le nom du fichier produit. Par défaut, le exécutable fichier s'appelle a.out.
-O, -O1, -O2, -O3 : options d'optimisations. Sans ces options, le but du compilateur est de minimiser le coût
Le C a été conçu en 1972 par Dennis Richie et Ken Thompson, chercheurs aux Bell Labs, afin de développer un de la compilation. En rajoutant l'une de ces options, le compilateur tente de réduire la taille du code
système d'exploitation UNIX sur un DEC PDP-11. En 1978, Brian Kernighan et Dennis Richie publient la exécutable et le temps d'exécution. Les options correspondent à différents niveaux d'optimisation : -O1
définition classique du C dans le livre The C Programming language [6]. Le C devenant de plus en plus (similaire à -O) correspond à une faible optimisation, -O3 à l'optimisation maximale.
populaire dans les années 80, plusieurs groupes mirent sur le marché des compilateurs comportant des extensions -S : n'active que le préprocesseur et le compilateur ; produit un fichier assembleur.
particulières. En 1983, l'ANSI (American National Standards Institute) décida de normaliser le langage ; ce -v : imprime la liste des commandes exécutées par les différentes étapes de la compilation.
travail s'acheva en 1989 par la définition de la norme ANSI C. Celle-ci fut reprise telle quelle par l'ISO -W : imprime des messages d'avertissement (warning) supplémentaires.
(International Standards Organization) en 1990. C'est ce standard, ANSI C, qui est décrit dans le présent -Wall : imprime tous les messages d'avertissement.
document.

3 Les composants élémentaires du C

2 La compilation
Un programme en langage C est constitué des six groupes de composants élémentaires suivants :
Le C est un langage compilé (par opposition aux langages interprétés). Cela signifie qu'un programme C est
décrit par un fichier texte, appelé fichier source. Ce fichier n'étant évidemment pas exécutable par le • les identificateurs,
microprocesseur, il faut le traduire en langage machine. Cette opération est effectuée par un programme appelé • les mots-clefs,
compilateur. La compilation se décompose en fait en 4 phases successives : • les constantes,
• les chaînes de caractères,
1. Le traitement par le préprocesseur : le fichier source est analysé par le préprocesseur qui effectue des
• les opérateurs,
transformations purement textuelles (remplacement de chaînes de caractères, inclusion d'autres fichiers source
...). • les signes de ponctuation.
2. La compilation : la compilation proprement dite traduit le fichier généré par le préprocesseur en assembleur,
c'est-à-dire en une suite d'instructions du microprocesseur qui utilisent des mnémoniques rendant la lecture On peut ajouter à ces six groupes les commentaires, qui sont enlevés par le préprocesseur.
possible.
3. L'assemblage : cette opération transforme le code assembleur en un fichier binaire, c'est-à-dire en instructions
directement compréhensibles par le processeur. Généralement, la compilation et l'assemblage se font dans la 3.1 Les identificateurs
foulée, sauf si l'on spécifie explicitement que l'on veut le code assembleur. Le fichier produit par l'assemblage est
appelé fichier objet. Le rôle d'un identificateur est de donner un nom à une entité du programme. Plus précisément, un identificateur
4. L'édition de liens : un programme est souvent séparé en plusieurs fichiers source, pour des raisons de clarté peut désigner :
mais aussi parce qu'il fait généralement appel à des librairies de fonctions standard déjà écrites. Une fois chaque
code source assemblé, il faut donc lier entre eux les différents fichiers objets. L'édition de liens produit alors un - un nom de variable ou de fonction,
fichier dit exécutable. - un type défini par typedef, struct, union ou enum,
- une étiquette.
Les différents types de fichiers utilisés lors de la compilation sont distingués par leur suffixe. Les fichiers source
sont suffixés par .c, les fichiers prétraités par le préprocesseur par .i, les fichiers assembleur par .s, et les fichiers Un identificateur est une suite de caractères parmi :
objet par .o. Les fichiers objets correspondant aux librairies pré-compilées ont pour suffixe .a.
- les lettres (minuscules ou majuscules, mais non accentuées),
Le compilateur C sous UNIX s'appelle cc. On utilisera de préférence le compilateur gcc du projet GNU. Ce - les chiffres,
compilateur est livré gratuitement avec sa documentation et ses sources. Par défaut, gcc active toutes les étapes - le ``blanc souligné'' (_).
de la compilation. On le lance par la commande
gcc [options] fichier.c [-llibrairies] Le premier caractère d'un identificateur ne peut pas être un chiffre. Par exemple, var1, tab_23 ou _deb sont des
identificateurs valides ; par contre, 1i et i:j ne le sont pas. Il est cependant déconseillé d'utiliser « _ » comme
Par défaut, le fichier exécutable s'appelle a.out. Le nom de l'exécutable peut être modifié à l'aide de l'option -o. premier caractère d'un identificateur car il est souvent employé pour définir les variables globales de
Les éventuelles librairies sont déclarées par la chaîne -llibrairie. Dans ce cas, le système recherche le fichier l'environnement C.
liblibrairie.a dans le répertoire contenant les librairies pré-compilées (généralement /usr/lib/). Par exemple, pour
lier le programme avec la librairie mathématique, on spécifie -lm. Le fichier objet correspondant est libm.a. ATTENTION : Les majuscules et minuscules sont différenciées.
Lorsque les librairies pré-compilées ne se trouvent pas dans le répertoire usuel, on spécifie leur chemin d'accès
par l'option -L. Le compilateur peut tronquer les identificateurs au-delà d'une certaine longueur. Cette limite dépend des
implémentations, mais elle est toujours supérieure à 31 caractères. (Le standard dit que les identificateurs
Les options les plus importantes du compilateur gcc sont les suivantes : externes, c'est-à-dire ceux qui sont exportés à l'édition de lien, peuvent être tronqués à 6 caractères, mais
tous les compilateurs modernes distinguent au moins 31 caractères).
-c : supprime l'édition de liens ; produit un fichier objet.
-E : n'active que le préprocesseur (le résultat est envoyé sur la sortie standard).
-g : produit des informations symboliques nécessaires au débogueur.
-Inom-de-répertoire : spécifie le répertoire dans lequel doivent être recherchés les fichiers en-têtes à inclure
(en plus du répertoire courant).

4 5
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

3.2 Les mots-clefs if (x != 0)

{
Un certain nombre de mots, appelés mots-clefs, sont réservés pour le langage lui-même et ne peuvent pas être z = y / x;
utilisés comme identificateurs. L'ANSI C compte 32 mots clefs : t = y % x;
}

auto const double float int short struct unsigned Une instruction composée d'un spécificateur de type et d'une liste d'identificateurs séparés par une virgule est une
break continue else for long signed switch void déclaration. Par exemple,
case default enum goto register sizeof typedef volatile
char do extern if return static union while int a;
int b = 2, c;
que l'on peut ranger en catégories : double x = 2.38e4;
char message[80];
• les spécificateurs de stockage
ATTENTION : En C, toute variable doit faire l'objet d'une déclaration avant d'être utilisée.
auto register static extern typedef

• les spécificateurs de type

Un programme C se présente de la façon suivante :
char double enum float int long short signed struct union unsigned void
[directives au préprocesseur]
• les qualificateurs de type [déclarations de variables externes]
const volatile [fonctions secondaires]
• les instructions de contrôle main()
break case continue default do else for goto if switch while { déclarations de variables internes,
instructions
• divers }
return sizeof
La fonction principale main peut avoir des paramètres formels. On supposera dans un premier temps que la
fonction main n'a pas de valeur de retour. Ceci est toléré par le compilateur mais produit un message
d'avertissement quand on utilise l'option -Wall de gcc.

3.3 Les commentaires Les fonctions secondaires peuvent être placées indifféremment avant ou après la fonction principale. Une
fonction secondaire peut se décrire de la manière suivante :
Un commentaire débute par /* et se termine par */. Par exemple,
type ma_fonction ( arguments )
/* Ceci est un commentaire */ {déclarations de variables internes
instructions
On ne peut pas imbriquer des commentaires. Quand on met en commentaire un morceau de programme, il faut }
donc veiller à ce que celui-ci ne contienne pas de commentaire.
Cette fonction retournera un objet dont le type sera type (à l'aide d'une instruction comme return objet;). Les
arguments de la fonction obéissent à une syntaxe voisine de celle des déclarations : on met en argument de la
fonction une suite d'expressions type objet séparées par des virgules. Par exemple, la fonction secondaire
4 Structure d'un programme C suivante calcule le produit de deux entiers :

Une expression est une suite de composants élémentaires syntaxiquement correcte, par exemple int produit(int a, int b)
x=0 {
ou bien int resultat;

(i >= 0) && (i < 10) && (p[i] != 0) resultat = a * b;

return(resultat);
}

Une instruction est une expression suivie d'un point-virgule. Le point-virgule signifie en quelque sorte ``évaluer
cette expression''. Plusieurs instructions peuvent être rassemblées par des accolades { et } pour former une
instruction composée ou bloc qui est syntaxiquement équivalent à une instruction. Par exemple,

6 7
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

5 Les types prédéfinis 6 Les constantes

Le C est un langage typé. Cela signifie en particulier que toute variable, constante ou fonction est d'un type Une constante est une valeur qui apparaît littéralement dans le code source d'un programme, le type de la
précis. Le type d'un objet définit la façon dont il est représenté en mémoire. constante étant déterminé par la façon dont la constante est écrite. Les constantes peuvent être de 4 types : entier,
flottant (nombre réel), caractère, énumération. Ces constantes vont être utilisées, par exemple, pour initialiser
La mémoire de l'ordinateur se décompose en une suite continue d'octets. Chaque octet de la mémoire est une variable.
caractérisé par son adresse, qui est un entier. Deux octets contigus en mémoire ont des adresses qui diffèrent
d'une unité. Quand une variable est définie, il lui est attribué une adresse. Cette variable correspondra à une zone
mémoire dont la longueur (le nombre d'octets) est fixée par le type. 6.1 Les constantes entières

La taille mémoire correspondant aux différents types dépend des compilateurs ; toutefois, la norme ANSI Une constante entière peut être représentée de 3 manières différentes suivant la base dans laquelle elle est écrite :
spécifie un certain nombre de contraintes.
décimale : par exemple, 0 et 2437348 sont des constantes entières décimales.
Les types de base en C concernent les caractères, les entiers et les flottants (nombres réels). Ils sont désignés par octale : la représentation octale d'un entier correspond à sa décomposition en base 8. Les constantes octales
les mots-clefs suivants : doivent commencer par un zéro. Par exemple, les représentations octales des entiers 0 et 255 sont
respectivement 00 et 0377.
char int float double short long unsigned hexadécimale : la représentation hexadécimale d'un entier correspond à sa décomposition en base 16. Les lettres
de a à f sont utilisées pour représenter les nombres de 10 à 15. Les constantes hexadécimales doivent
commencer par 0x ou 0X. Par exemple, les représentations hexadécimales de 14 et 255 sont respectivement
5.1 Le type caractère 0xe et 0xff.

Le mot-clef char désigne un objet de type caractère. Un char peut contenir n'importe quel élément du jeu de On peut spécifier explicitement le format d'une constante entière en la suffixant par u ou U pour indiquer qu'elle
caractères de la machine utilisée. La plupart du temps, un objet de type char est codé sur un octet ; c'est l'objet le est non signée, ou en la suffixant par l ou L pour indiquer qu'elle est de type long. Par exemple :
plus élémentaire en C. Le jeu de caractères utilisé correspond généralement au codage ASCII (sur 7 bits). La
plupart des machines utilisent désormais le jeu de caractères ISO-8859 (sur 8 bits), dont les 128 premiers
caractères correspondent aux caractères ASCII. Les 128 derniers caractères (codés sur 8 bits) sont utilisés pour Constante type
les caractères propres aux différentes langues. 1234 int
02322 int /* octal */
Une des particularités du type char en C est qu'il peut être assimilé à un entier : tout objet de type char peut être 0x4D2 int /* hexadécimal */
utilisé dans une expression qui utilise des objets de type entier. Par exemple, si c est de type char, l'expression c 123456789L long
+ 1 est valide. Elle désigne le caractère suivant dans le code ASCII. Ainsi, le programme suivant imprime le 1234U unsigned int
caractère 'B'. 123456789UL unsigned long int

main()
{ 6.2 Les constantes réelles
char c = 'A';
printf("%c", c + 1); Les constantes réelles sont représentées par la notation classique par mantisse et exposant. L'exposant est
} introduit par la lettre e ou E ; il s'agit d'un nombre décimal éventuellement signé.

Par défaut, une constante réelle est représentée avec le format du type double. On peut cependant influer sur la
représentation interne de la constante en lui ajoutant un des suffixes f (indifféremment F) ou l (indifféremment
5.2 Les types entiers L). Les suffixes f et F forcent la représentation de la constante sous forme d'un float, les suffixes l et L forcent la
représentation sous forme d'un long double. Par exemple :
Le mot-clef désignant le type entier est int. Un objet de type int est représenté par un mot ``naturel'' de la
machine utilisée, 32 bits pour un DEC alpha ou un PC Intel.
Constante type
Le type int peut être précédé d'un attribut de précision (short ou long) et/ou d'un attribut de représentation 12.34 double
(unsigned).Un objet de type short int a au moins la taille d'un char et au plus la taille d'un int. En général, un 12.3e-4 double
short int est codé sur 16 bits. Un objet de type long int a au moins la taille d'un int (64 bits sur un DEC alpha, 32 12.34F float
bits sur un PC Intel). 12.34L long double

6.3 Les constantes caractères

5.3 Les types flottants
Pour désigner un caractère imprimable, il suffit de le mettre entre apostrophes (par ex. 'A' ou '$'). Les seuls
Les types float, double et long double servent à représenter des nombres en virgule flottante. Ils correspondent caractères imprimables qu'on ne peut pas représenter de cette façon sont l'antislash et l'apostrophe, qui sont
aux différentes précisions possibles. respectivement désignés par \\ et \'. Le point d'interrogation et les guillemets peuvent aussi être désignés par les
notations \? et \". Les caractères non imprimables peuvent être désignés par '\code-octal' où code-octal est le code

8 9
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

en octal du caractère. On peut aussi écrire '\xcode-hexa' où code-hexa est le code en hexadécimal du caractère
(cf. page X). Par exemple, '\33' et '\x1b' désignent le caractère escape. Toutefois, les caractères non-imprimables 7.2 Les opérateurs arithmétiques
les plus fréquents disposent aussi d'une notation plus simple :
Les opérateurs arithmétiques classiques sont l'opérateur unaire - (changement de signe) ainsi que les opérateurs
\n nouvelle ligne binaires
\r retour chariot
\t tabulation horizontale + addition
\f saut de page - soustraction
\v tabulation verticale * multiplication
\a signal d'alerte / division
\b retour arrière % reste de la division (modulo)

Ces opérateurs agissent de la façon attendue sur les entiers comme sur les flottants. Leurs seules spécificités sont
les suivantes :
6.4 Les constantes chaînes de caractères
Contrairement à d'autres langages, le C ne dispose que de la notation / pour désigner à la fois la division entière
Une chaîne de caractères est une suite de caractères entourés par des guillemets. Par exemple, et la division entre flottants. Si les deux opérandes sont de type entier, l'opérateur / produira une division entière
(quotient de la division). Par contre, il délivrera une valeur flottante dès que l'un des opérandes est un flottant.
"Ceci est une chaîne de caractères" Par exemple,

Une chaîne de caractères peut contenir des caractères non imprimables, désignés par les représentations vues float x;
précédemment. Par exemple, x = 3 / 2;

"ligne 1 \n ligne 2" affecte à x la valeur 1. Par contre

A l'intérieur d'une chaîne de caractères, le caractère " doit être désigné par \". Enfin, le caractère \ suivi d'un x = 3 / 2.;
passage à la ligne est ignoré. Cela permet de faire tenir de longues chaînes de caractères sur plusieurs lignes. Par
exemple, affecte à x la valeur 1.5.

"ceci est une longue longue longue longue longue longue longue longue \ L'opérateur % ne s'applique qu'à des opérandes de type entier. Si l'un des deux opérandes est négatif, le signe du
chaîne de caractères" reste dépend de l'implémentation, mais il est en général le même que celui du dividende.

Notons enfin qu'il n'y a pas en C d'opérateur effectuant l'élévation à la puissance. De façon générale, il faut
utiliser la fonction pow(x,y) de la librairie math.h
7 Les opérateurs pour calculer x^y.

7.1 L'affectation
En C, l'affectation est un opérateur à part entière. Elle est symbolisée par le signe =. Sa syntaxe est la suivante : 7.3 Les opérateurs relationnels
variable = expression
Le terme de gauche de l'affectation peut être une variable simple, un élément de tableau mais pas une constante. > supérieur
Cette expression a pour effet d'évaluer expression et d'affecter la valeur obtenue à variable. De plus, cette >= supérieur ou égal
expression possède une valeur, qui est celle expression. Ainsi, l'expression i = 5 vaut 5. < strictement inférieur
<= inférieur ou égal
L'affectation effectue une conversion de type implicite : la valeur de l'expression (terme de droite) est convertie == égal
dans le type du terme de gauche.Par exemple, le programme suivant != différent

main() Leur syntaxe est

{ expression1 op expression2
int i, j = 2;
float x = 2.5; Les deux expressions sont évaluées puis comparées. La valeur rendue est de type int (il n'y a pas de type booléen
i = j + x; en C); elle vaut 1 si la condition est vraie, et 0 sinon.
x = x + i;
printf("\n %f \n",x); ATTENTION : à ne pas confondre l'opérateur de test d'égalité = = avec l'opérateur d'affection =. Ainsi, le
} programme
imprime pour x la valeur 6.5 (et non 7), car dans l'instruction i = j + x;, l'expression j + x a été convertie en main()
entier. {
int a = 0;
int b = 1;

10 11
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

if (a = b)
printf("\n a et b sont egaux \n"); 7.7 Les opérateurs d'incrémentation et de décrémentation
else
printf("\n a et b sont differents \n"); Les opérateurs d'incrémentation ++ et de décrémentation -- s'utilisent aussi bien en suffixe (i++) qu'en préfixe
} (++i). Dans les deux cas la variable i sera incrémentée, toutefois dans la notation suffixe la valeur retournée sera
l'ancienne valeur de i alors que dans la notation préfixe se sera la nouvelle. Par exemple,
imprime à l'écran a et b sont egaux !
int a = 3, b, c;
b = ++a; /* a et b valent 4 */
7.4 Les opérateurs logiques booléens c = b++; /* c vaut 4 et b vaut 5 */

&& et logique 7.8 L'opérateur virgule

|| ou logique
! négation logique Une expression peut être constituée d'une suite d'expressions séparées par des virgules :
expression1, expression2, ... , expressionN

Comme pour les opérateurs de comparaison, la valeur retournée par ces opérateurs est un int qui vaut 1 si la Cette expression est alors évaluée de gauche à droite. Sa valeur sera la valeur de l'expression de droite. Par
condition est vraie et 0 sinon. exemple, le programme

Dans une expression de type main()

expression1 op1 expression2 op2 ...expressionN {
l'évaluation se fait de gauche à droite et s'arrête dès que le résultat final est déterminé. Par exemple dans int a, b;
b = ((a = 3), (a + 2));
int i; printf("\n b = %d \n",b);
int p[10]; }

if ((i >= 0) && (i <= 9) && !(p[i] == 0)) imprime b = 5.

...
la dernière clause ne sera pas évaluée si i n'est pas entre 0 et 9.
7.9 L'opérateur conditionnel ternaire
L'opérateur conditionnel ? est un opérateur ternaire. Sa syntaxe est la suivante :
7.5 Les opérateurs logiques bit à bit condition ? expression1 : expression2
Cette expression est égale à expression1 si condition est satisfaite, et à expression2 sinon. Par exemple,
Les six opérateurs suivants permettent de manipuler des entiers au niveau du bit. Ils s'appliquent aux entiers de l'expression
toute longueur (short, int ou long), signés ou non.
x >= 0 ? x : -x

& et correspond à la valeur absolue d'un nombre. De même l'instruction

| ou inclusif
^ ou exclusif m = ((a > b) ? a : b);
~ complément à 1
<< décalage à gauche affecte à m le maximum de a et de b.
>> décalage à droite

7.10 L'opérateur de conversion de type

7.6 Les opérateurs d'affectation composée L'opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d'un objet. On écrit

Les opérateurs d'affectation composée sont (type) objet

+= -= *= /= %= &= ^= |= <<= >>= Par exemple,

Pour tout opérateur op, l'expression main()

expression1 op = expression2 {
est équivalente à int i = 3, j = 2;
expression1 = expression1 op expression2 printf("%f \n",(float)i/j);
Toutefois, avec l'affection composée, expression1 n'est évaluée qu'une seule fois. }

retourne la valeur 1.5.

12 13
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

Si la valeur de expression est égale à l'une des constantes, la liste d'instructions correspondant est exécutée.
Sinon la liste d'instructions
M correspondant à default est exécutée. L'instruction default est facultative.
7.11 L'opérateur adresse
L'opérateur d'adresse & appliqué à une variable retourne l'adresse mémoire de cette variable. La syntaxe est 9 Les boucles
&objet Les boucles permettent de répéter une série d'instructions tant qu'une certaine condition n'est pas vérifiée.

9.1 Boucle « while »

8 Les instructions de branchement conditionnel
La syntaxe de while est la suivante :
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 while (expression )
de branchement permettent de déterminer quelles instructions seront exécutées et dans quel ordre. instruction

Tant que expression est vérifiée (i.e., non nulle), instruction est exécutée. Si expression est nulle au départ,
8.1 Branchement conditionnel « if---else » instruction ne sera jamais exécutée.
instruction peut évidemment être une instruction composée. Par exemple, le programme suivant imprime les
La forme la plus générale est celle-ci : entiers de 1 à 9.

if (expression1 ) i = 1;
instruction1 while (i < 10)
else if (expression2 ) {
instruction2 printf("\n i = %d",i);
... i++;
else if (expressionN ) }
instructionN
else 9.2 Boucle « do---while »
instructionM
Il peut arriver que l'on ne veuille effectuer le test de continuation qu'après avoir exécuté l'instruction. Dans ce
avec un nombre quelconque de else if ( ... ). Le dernier else est toujours facultatif. La forme la plus simple est cas, on utilise la boucle do---while. Sa syntaxe est

if (expression ) do
instruction instruction
while (expression );
Chaque instruction peut être un bloc d'instructions.
Ici, instruction sera exécutée tant que expression est non nulle. Cela signifie donc que instruction est toujours
exécutée au moins une fois. Par exemple, pour saisir au clavier un entier entre 1 et 10 :
8.2 Branchement multiple « switch »
int a;
Sa forme la plus générale est celle-ci :
do
switch (expression ) {
{case constante1: printf("\n Entrez un entier entre 1 et 10 : ");
liste d'instructions 1 scanf("%d",&a);
break; }
case constante2: while ((a <= 0) || (a > 10));
liste d'instructions 2
break;
...
case constanteN: 9.3 Boucle « for »
liste d'instructions N
break; La syntaxe de for est :
default:
liste d'instructions M for (expr 1 ;expr 2 ;expr 3)
break; instruction
}
Une version équivalente plus intuitive est :

14 15
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

expr 1; 10.2 Branchement non conditionnel « continue »

while (expr 2 )
{instruction L'instruction continue permet de passer directement au tour de boucle suivant, sans exécuter les autres
expr 3; instructions de la boucle. Ainsi le programme
}
main()
Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit : {
int i;
for (i = 0; i < 10; i++) for (i = 0; i < 5; i++)
printf("\n i = %d",i); {
if (i == 3)
A la fin de cette boucle, i vaudra 10. Les trois expressions utilisées dans une boucle for peuvent être constituées continue;
de plusieurs expressions séparées par des virgules. Cela permet par exemple de faire plusieurs initialisations à la printf("i = %d\n",i);
fois. Par exemple, pour calculer la factorielle d'un entier, on peut écrire : }
printf("valeur de i a la sortie de la boucle = %d\n",i);
int n, i, fact; }
for (i = 1, fact = 1; i <= n; i++)
fact *= i; imprime
printf("%d ! = %d \n",n,fact);
i=0
On peut également insérer l'instruction fact *= i; dans la boucle for ce qui donne : i=1
i=2
int n, i, fact; i=4
for (i = 1, fact = 1; i <= n; fact *= i, i++); valeur de i à la sortie de la boucle = 5
printf("%d ! = %d \n",n,fact);

On évitera toutefois ce type d'acrobaties qui n'apportent rien et rendent le programme difficilement lisible.

11 Les fonctions d'entrées-sorties classiques

10 Les instructions de branchement non conditionnel 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
10.1 Branchement non conditionnel « break » préprocesseur

On a vu le rôle de l'instruction break; au sein d'une instruction de branchement multiple switch. L'instruction #include <stdio.h>
break peut, plus généralement, être employée à l'intérieur de n'importe quelle boucle. Elle permet d'interrompre
le déroulement de la boucle, et passe à la première instruction qui suit la boucle. En cas de boucles imbriquées, n'est pas nécessaire pour utiliser printf et scanf.
break fait sortir de la boucle la plus interne. Par exemple, le programme suivant :

main() 11.1 La fonction d'écriture « printf »

{
int i; La fonction printf est une fonction d'impression formatée, ce qui signifie que les données sont converties selon
for (i = 0; i < 5; i++) le format particulier choisi. Sa syntaxe est
{
printf("i = %d\n",i); printf("chaîne de contrôle ",expression1, ..., expressionN);
if (i == 3)
break; La chaîne de contrôle contient le texte à afficher et les spécifications de format correspondant à chaque
} expression de la liste. Les spécifications de format ont pour but d'annoncer le format des données à visualiser.
printf("valeur de i a la sortie de la boucle = %d\n",i); Elles sont introduites par le caractère %, suivi d'un caractère désignant le format d'impression. Les formats
} d'impression en C sont donnés dans la table 1suivante.

imprime à l'écran

i=0
i=1
i=2
i=3
valeur de i à la sortie de la boucle = 3

16 17
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

scanf("%x",&i);
Format conversion en écriture printf("i = %d\n",i);
%d int décimale signée }
%ld long int décimale signée
%u unsigned int décimale non signée Si on entre au clavier la valeur 1a, le programme affiche i = 26.
%lu unsigned long int décimale non signée
%o unsigned int octale non signée format type d'objet pointé représentation de la donnée saisie
%lo unsigned long int octale non signée %d int décimale signée
%x unsigned int hexadécimale non signée %hd short int décimale signée
%lx unsigned long int hexadécimale non signée %ld long int décimale signée
%f double décimale virgule fixe %u unsigned int décimale non signée
%lf long double décimale virgule fixe %hu unsigned short int décimale non signée
%e double décimale notation exponentielle %lu unsigned long int décimale non signée
%le long double décimale notation exponentielle %o int octale
%g double décimale, représentation la plus courte parmi %f et %e %ho short int octale
%lg long double décimale, représentation la plus courte parmi %lf et %le %lo long int octale
%c unsigned char caractère %x int hexadécimale
%s char* chaîne de caractères %hx short int hexadécimale
%lx long int hexadécimale
Table 1: Formats d'impression pour la fonction printf %f float flottante virgule fixe
%lf double flottante virgule fixe
%Lf long double flottante virgule fixe
En plus du caractère donnant le type des données, on peut éventuellement préciser certains paramètres du format %e float flottante notation exponentielle
d'impression, qui sont spécifiés entre le % et le caractère de conversion dans l'ordre suivant : %le double flottante notation exponentielle
%Le long double flottante notation exponentielle
• largeur minimale du champ d'impression : %10d spécifie qu'au moins 10 caractères seront réservés pour %g float flottante virgule fixe ou notation exponentielle
imprimer l'entier. Par défaut, la donnée sera cadrée à droite du champ. Le signe - avant le format signifie %lg double flottante virgule fixe ou notation exponentielle
que la donnée sera cadrée à gauche du champ (%-10d). %Lg long double flottante virgule fixe ou notation exponentielle
• précision : %.12f signifie qu'un flottant sera imprimé avec 12 chiffres après la virgule. De même %10.2f %c char caractère
signifie que l'on réserve 12 caractères (incluant le caractère .) pour imprimer le flottant et que 2 d'entre eux %s char* chaîne de caractères
sont destinés aux chiffres après la virgule. Lorsque la précision n'est pas spécifiée, elle correspond par
défaut à 6 chiffres après la virgule. Pour une chaîne de caractères, la précision correspond au nombre de
caractères imprimés : %30.4s signifie que l'on réserve un champ de 30 caractères pour imprimer la chaîne Table 2: Formats de saisie pour la fonction scanf
mais que seulement les 4 premiers caractères seront imprimés (suivis de 26 blancs).

11.2 La fonction de saisie « scanf » 11.3 Impression et lecture de caractères

La fonction scanf permet de saisir des données au clavier et de les stocker aux adresses spécifiées par les Les fonctions getchar et putchar permettent respectivement de lire et d'imprimer des caractères. Il s'agit de
arguments de la fonctions. fonctions d'entrées-sorties non formatées.
scanf("chaîne de contrôle",argument1,...,argumentN)
La fonction getchar retourne un int correspondant au caractère lu. Pour mettre le caractère lu dans une variable
La chaîne de contrôle indique le format dans lequel les données lues sont converties. Elle ne contient pas d'autres caractere, on écrit
caractères (notamment pas de \n). caractere = getchar();
Comme pour printf, les conversions de format sont spécifiées par un caractère précédé du signe %. Les formats
valides pour la fonction scanf diffèrent légèrement de ceux de la fonction printf et sont donnés dans la table 2. Lorsqu'elle détecte la fin de fichier, elle retourne l'entier EOF (End Of File), valeur définie dans la librairie
stdio.h. En général, la constante EOF vaut -1.
Les données à entrer au clavier doivent être séparées par des blancs ou des <RETURN> sauf s'il s'agit de
caractères. On peut toutefois fixer le nombre de caractères de la donnée à lire. Par exemple %3s pour une chaîne La fonction putchar écrit caractere sur la sortie standard :
de 3 caractères, %10d pour un entier qui s'étend sur 10 chiffres, signe inclus. putchar(caractere);

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

#include <stdio.h>
main()
{
int i;
printf("entrez un entier sous forme hexadecimale i = ");

18 19
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

int i;
for (i = 0; i < N; i++)
printf("tab[%d] = %d\n",i,tab[i]);
}
12 Les types composés
Si le nombre de données dans la liste d'initialisation est inférieur à la dimension du tableau, seuls les premiers
A partir des types prédéfinis du C (caractères, entiers, flottants), on peut créer de nouveaux types, appelés types éléments seront initialisés. Les autres éléments seront mis à zéro si le tableau est une variable globale (extérieure
composés, qui permettent de représenter des ensembles de données organisées. à toute fonction) ou une variable locale de classe de mémorisation static.

De la même manière un tableau de caractères peut être initialisé par une liste de caractères, mais aussi par une
12.1 Les tableaux chaîne de caractères littérale. Notons que le compilateur complète toute chaîne de caractères avec un caractère
nul '\0'. Il faut donc que le tableau ait au moins un élément de plus que le nombre de caractères de la chaîne
Un tableau est un ensemble fini d'éléments de même type, stockés en mémoire à des adresses contiguës. littérale.
La déclaration d'un tableau à une dimension se fait de la façon suivante : #define N 8
type nom-du-tableau[nombre-éléments]; char tab[N] = "exemple";
où nombre-éléments est une expression constante entière positive. Par exemple, la déclaration int tab[10]; main()
indique que tab est un tableau de 10 éléments de type int. Cette déclaration alloue donc en mémoire pour l'objet {
tab un espace de 10 × 4 octets consécutifs. int i;
for (i = 0; i < N; i++)
Pour plus de clarté, il est recommandé de donner un nom à la constante nombre-éléments par une directive au printf("tab[%d] = %c\n",i,tab[i]);
préprocesseur, par exemple }
#define nombre-éléments 10
Lors d'une initialisation, il est également possible de ne pas spécifier le nombre d'éléments du tableau. Par
On accède à un élément du tableau en lui appliquant l'opérateur []. Les éléments d'un tableau sont toujours défaut, il correspondra au nombre de constantes de
numérotés de 0 à nombre-éléments -1. Le programme suivant imprime les éléments du tableau tab : la liste d'initialisation. Ainsi le programme suivant imprime le nombre de caractères du tableau tab, ici 8.
#define N 10 char tab[] = "exemple";
main() main()
{ {
int tab[N]; int i;
int i; printf("Nombre de caracteres du tableau = %d\n",sizeof(tab)/sizeof(char));
... }
for (i = 0; i < N; i++)
printf("tab[%d] = %d\n",i,tab[i]); De manière similaire, on peut déclarer un tableau à plusieurs dimensions. Par exemple, pour un tableau à deux
} dimensions :
type nom-du-tableau[nombre-lignes][nombre-colonnes]
Un tableau correspond en fait à un pointeur vers le premier élément du tableau. Ce pointeur est constant. Cela En fait, un tableau à deux dimensions est un tableau unidimensionnel dont chaque élément est lui-même un
implique en particulier qu'aucune opération globale n'est autorisée sur un tableau. Notamment, un tableau ne tableau. On accède à un élément du tableau par
peut pas figurer à gauche d'un opérateur d'affectation. Par exemple, on ne peut pas écrire ``tab1 = tab2;''. Il faut l'expression ``tableau[i][j]''. Pour initialiser un tableau à plusieurs dimensions à la compilation, on utilise une
effectuer l'affectation pour chacun des éléments du tableau : liste dont chaque élément est une liste de
constantes :
#define N 10
main() #define M 2
{ #define N 3
int tab1[N], tab2[N]; int tab[M][N] = {{1, 2, 3}, {4, 5, 6}};
int i;
... main()
for (i = 0; i < N; i++) {
tab1[i] = tab2[i]; int i, j;
} for (i = 0 ; i < M; i++)
{
On peut initialiser un tableau lors de sa déclaration par une liste de constantes de la façon suivante : for (j = 0; j < N; j++)
type nom-du-tableau[N] = {constante1,constante2,...,constanteN}; printf("tab[%d][%d]=%d\n",i,j,tab[i][j]);
}
Par exemple, on peut écrire }
#define N 4
int tab[N] = {1, 2, 3, 4};
main()
{

20 21
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

struct complexe z1, z2;

12.2 Les structures ...
z2 = z1;
Une structure est une suite finie d'objets de types différents. Contrairement aux tableaux, les différents éléments }
d'une structure n'occupent pas nécessairement des zones contiguës en mémoire. Chaque élément de la structure,
appelé membre ou champ, est désigné par un identificateur. 12.3 Les champs de bits

On distingue la déclaration d'un modèle de structure de celle d'un objet de type structure correspondant à un Il est possible en C de spécifier la longueur des champs d'une structure au bit près si ce champ est de type entier
modèle donné. La déclaration d'un modèle de structure dont l'identificateur est modele suit la syntaxe suivante : (int ou unsigned int). Cela se fait en précisant le nombre de bits du champ avant le ; qui suit sa déclaration. Par
exemple, la structure suivante
struct modele
{type1 membre1; struct registre
type2 membre2; {
... unsigned int actif : 1;
typeN membreN; unsigned int valeur : 31;
}; };

Pour déclarer un objet de type structure correspondant au modèle précédent, on utilise la syntaxe : possède deux membres, actif qui est codé sur un seul bit, et valeur qui est codé sur 31 bits. Tout objet de type
struct modele objet; struct registre est donc codé sur 32 bits. Toutefois, l'ordre dans lequel les champs sont placés à l'intérieur de ce
ou bien, si le modèle n'a pas été déclaré au préalable : mot de 32 bits dépend de l'implémentation.

struct modele Le champ actif de la structure ne peut prendre que les valeurs 0 et 1. Aussi, si r est un objet de type struct
{type1 membre1; registre, l'opération r.actif += 2; ne modifie pas la valeur du champ.
type2 membre2;
... La taille d'un champ de bits doit être inférieure au nombre de bits d'un entier. Notons enfin qu'un champ de bits
typeN membreN; n'a pas d'adresse ; on ne peut donc pas lui appliquer l'opérateur &.
}objet;

On accède aux différents membres d'une structure grâce à l'opérateur membre de structure, noté ``.''. Le i-ème 12.4 Les unions
membre de objet est désigné par l'expression
objet.membre-i Une union désigne un ensemble de variables de types différents susceptibles d'occuper alternativement une
On peut effectuer sur le i-ème membre de la structure toutes les opérations valides sur des données de type type- même zone mémoire. Une union permet donc de
i. Par exemple, le programme suivant définit la structure complexe, composée de deux champs de type double ; il définir un objet comme pouvant être d'un type au choix parmi un ensemble fini de types. Si les membres d'une
calcule la norme d'un nombre complexe. union sont de longueurs différentes, la place
réservée en mémoire pour la représenter correspond à la taille du membre le plus grand.
#include <math.h>
struct complexe Les déclarations et les opérations sur les objets de type union sont les mêmes que celles sur les objets de type
{ struct. Dans l'exemple suivant, la variable hier de type union jour peut être soit un entier, soit un caractère.
double reelle;
double imaginaire; union jour
}; {
char lettre;
main() int numero;
{ };
struct complexe z;
double norme; main()
... {
norme = sqrt(z.reelle * z.reelle + z.imaginaire * z.imaginaire); union jour hier, demain;
printf("norme de (%f + i %f) = %f \n",z.reelle,z.imaginaire,norme); hier.lettre = 'J';
} printf("hier = %c\n",hier.lettre);
hier.numero = 4;
Les règles d'initialisation d'une structure lors de sa déclaration sont les mêmes que pour les tableaux. On écrit par demain.numero = (hier.numero + 2) % 7;
exemple : printf("demain = %d\n",demain.numero);
struct complexe z = {2. , 2.}; }
En ANSI C, on peut appliquer l'opérateur d'affectation aux structures (à la différence des tableaux). Dans le
contexte précédent, on peut écrire : Les unions peuvent être utiles lorsqu'on a besoin de voir un objet sous des types différents (mais en général de
même taille). Par exemple, le programme suivant
... permet de manipuler en même temps les deux champs de type unsigned int d'une structure en les identifiant à un
main() objet de type unsigned long (en
{ supposant que la taille d'un entier long est deux fois celle d'un int).

22 23
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

typedef struct complexe complexe;

struct coordonnees
{ main()
unsigned int x; {
unsigned int y; complexe z;
}; ...
union point }
{
struct coordonnees coord;
unsigned long mot;
};

main()
{
union point p1, p2, p3;
p1.coord.x = 0xf;
p1.coord.y = 0x1;
p2.coord.x = 0x8;
p2.coord.y = 0x8;
p3.mot = p1.mot ^ p2.mot;
printf("p3.coord.x = %x \t p3.coord.y = %x\n", p3.coord.x, p3.coord.y);
}

12.5 Les énumérations

Les énumérations permettent de définir un type par la liste des valeurs qu'il peut prendre. Un objet de type
énumération est défini par le mot-clef enum et un identificateur de modèle, suivis de la liste des valeurs que peut
prendre cet objet :
enum modele {constante-1, constante-2,...,constante-n};

En réalité, les objets de type enum sont représentés comme des int. Les valeurs possibles constante-1, constante-
2,...,constante-n sont codées par des entiers de 0 à n-1. Par exemple, le type enum booleen défini dans le
programme suivant associe l'entier 0 à la valeur faux et l'entier 1 à la valeur vrai.

main()
{
enum booleen {faux, vrai};
enum booleen b;
b = vrai;
printf("b = %d\n",b);
}

On peut modifier le codage par défaut des valeurs de la liste lors de la déclaration du type énuméré, par exemple
:
enum booleen {faux = 12, vrai = 23};

12.6 Définition de types composés avec typedef

Pour alléger l'écriture des programmes, on peut affecter un nouvel identificateur à un type composé à l'aide de
typedef :
typedef type synonyme;
Par exemple,

struct complexe
{
double reelle;
double imaginaire;
};

24 25
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

Attention : Les pointeurs et les noms de variables ont le même rôle : Ils donnent accès à un emplacement dans
13 Les pointeurs la mémoire interne de l'ordinateur. Il faut quand même bien faire la différence :
• Un pointeur est une variable qui peut 'pointer' sur différentes adresses.
• Le nom d'une variable reste toujours lié à la même adresse.
13.1 Introduction
13.2 Les opérateurs de base
Avant de parler de pointeurs, nous allons brièvement passer en revue les deux modes d'adressage principaux :
Lors du travail avec des pointeurs, nous avons besoin
Adressage direct : Dans la programmation, nous utilisons des variables pour stocker des informations. La
valeur d'une variable se trouve à un endroit spécifique dans la mémoire interne de l'ordinateur. Le nom de la - d'un opérateur 'adresse de': & pour obtenir l'adresse d'une variable.
variable nous permet alors d'accéder directement à cette valeur. - d'un opérateur 'contenu de': * pour accéder au contenu d'une adresse.
- d'une syntaxe de déclaration pour pouvoir déclarer un pointeur.
Adressage direct = Accès au contenu d'une variable par le nom de la variable.

Exemple : 13.2.1 L'opérateur 'adresse de' : &

short X ; &<NomVariable> fournit l'adresse de la variable <NomVariable>
X = 20 ;
X L'opérateur & nous est déjà familier par la fonction scanf, qui a besoin de l'adresse de ses arguments pour
pouvoir leur attribuer de nouvelles valeurs.

... 20 ... ... ... Exemple

Adresse 6B02 6B04 6B06 6B0A 6B0B int X;

printf("Entrez un nombre entier : ");
scanf("%d", &X);
Adressage indirect : Si nous ne voulons pas ou encore nous ne pouvons pas utiliser le nom d'une variable
X, nous pouvons copier l'adresse de cette variable dans une variable spéciale P, appelée pointeur. Ensuite, nous Soit P un pointeur non initialisé et X une variable (du même type) contenant la valeur 20 :
pouvons retrouver l'information de la variable X en passant par le pointeur P. Alors l'instruction

Adressage indirect = Accès au contenu d'une variable, en passant par un pointeur P = &X; affecte l'adresse de la variable X à la variable P.
qui contient l'adresse de la variable.

Exemple 13.2.2 L'opérateur 'contenu de' : *

Soit X une variable contenant la valeur 20 et P un pointeur qui contient l'adresse de X. En mémoire, X et P *<NomPointeur> désigne le contenu de l'adresse référencée par le pointeur <NomPointeur>
peuvent se présenter comme suit:
Exemple

P X int X , Y;
int *P ;

... 6B04 ... ... 20 P: • X : 20 Y : 40

Adresse 1A02 1A04 1A06 6B04 6B06

Soit X une variable contenant la valeur 20, Y une variable contenant la valeur 40 et P un pointeur non initialisé:
Après les instructions,
La plupart des langages de programmation offrent la possibilité d'accéder aux données dans la mémoire de
l'ordinateur à l'aide de pointeurs, c.-à-d. à l'aide de variables auxquelles on peut attribuer les adresses d'autres P = &X;
variables. Y = *P;
On peut donc définir un pointeur comme une variable spéciale qui peut contenir l'adresse d'une autre variable. *P = 100;
En C, chaque pointeur est limité à un type de données.

Si un pointeur P contient l'adresse d'une variable X, on dit que

' P pointe sur X '. P: • X : 100 Y : 20

26 27
Module II20 (Remise à niveau en programmation C) S.Otmane Module II20 (Remise à niveau en programmation C) S.Otmane

int *P;
- P pointe sur X,
- le contenu de X (référencé par *P) est affecté à Y, et
- le contenu de X (référencé par *P) est mis à 100.

P: •
La déclaration d'un pointeur est comme suit :

<Type> *<NomPointeur>
déclare un pointeur <NomPointeur> qui peut recevoir des adresses de variables du type <Type> T: ...

Une déclaration comme

l'instruction:
int *P_num; P = T; est équivalente à P = &T[0];

peut être interprétée comme suit: Si P pointe sur une composante quelconque d'un tableau, alors P+1 pointe sur la composante suivante. Plus
généralement,
"*P-num est du type int" ou "P_num est un pointeur sur int" ou
"P_num peut contenir l'adresse d'une variable du type int" P+i pointe sur la i-ième composante derrière P et
P-i pointe sur la i-ième composante devant P.

13.3 Les opérations élémentaires sur pointeurs Ainsi, après l'instruction,

En travaillant avec des pointeurs, nous devons observer les règles suivantes: P = T; le pointeur P pointe sur T[0], et

Priorité de * et & *(P+1) désigne le contenu de T[1]

*(P+2) désigne le contenu de T[2]
...
• Les opérateurs * et & ont la même priorité que les autres opérateurs unaires (la négation !, l'incrémentation
*(P+i) désigne le contenu de T[i]
++, la décrémentation --). Dans une même expression, les opérateurs unaires *, &, !, ++, -- sont évalués de
droite à gauche.

• Si un pointeur P pointe sur une variable X, alors *P peut être utilisé partout où on peut écrire X.
13.5 Pointeurs et chaînes de caractères
Exemple
De la même façon qu'un pointeur sur int peut contenir l'adresse d'un nombre isolé ou d'une composante d'un
Après l'instruction P = &X;
tableau, un pointeur sur char peut pointer sur un caractère isolé ou sur les éléments d'un tableau de caractères.
Un pointeur sur char peut en plus contenir l'adresse d'une chaîne de caractères constante et il peut même être
les expressions suivantes, sont équivalentes:
initialisé avec une telle adresse.
Y = *P+1 Y = X+1
*P = *P+10 X = X+10
*P += 2 X += 2 13.5.1 Affectation
++*P ++X
(*P)++ X++ On peut attribuer l'adresse d'une chaîne de caractères constante à un pointeur sur char :

Exemple

char *c;
13.4 Adressage des composantes d'un tableau c = "Salut !";
Comme nous l'avons déjà constaté, le nom d'un tableau représente l'adresse de son premier élément. En d'autre
termes:
c: •
&tableau[0] et tableau sont une seule et même adresse.

En simplifiant, nous pouvons retenir que le nom d'un tableau est un pointeur constant sur le premier élément du
tableau, par exemple : ‘S’ ‘a’ ‘l’ ‘u’ ‘t’ ‘‘ ‘!’ ‘\O’

En déclarant un tableau T de type int et un pointeur P sur int,

int T[20];

28 29
Module II20 (Remise à niveau en programmation C) S.Otmane

Nous pouvons lire cette chaîne constante (par exemple : pour l'afficher), mais il n'est pas recommandé de la
modifier, parce que le résultat d'un programme qui essaie de modifier une chaîne de caractères constante n'est
pas prévisible en ANSI-C.

13.5.2 Initialisation
Un pointeur sur char peut être initialisé lors de la déclaration si on lui affecte l'adresse d'une chaîne de caractères
constante:

char *C = "Salut !";

Attention ! : Il existe une différence importante entre les deux déclarations:

char T[] = "Salut !"; /* un tableau */
char *C = "Salut !"; /* un pointeur */

T est un tableau qui a exactement la grandeur pour contenir la chaîne de caractères et la terminaison '\0'. Les
caractères de la chaîne peuvent être changés, mais le nom T va toujours pointer sur la même adresse en mémoire.

C est un pointeur qui est initialisé de façon à ce qu'il pointe sur une chaîne de caractères constante stockée
quelque part en mémoire. Le pointeur peut être modifié et pointer sur autre chose. La chaîne constante peut être
lue, copiée ou affichée, mais pas modifiée.

14 Quelques conseils pour l’é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.
• 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.
• 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 (ou un autre éditeur de texte équivalent).

Références
[1] Braquelaire (J.-P.). -- Méthodologie de la programmation en C. --
Dunod, 2000, troisième édition.

[3] Cassagne (B.). -- Introduction au langage C. --

http://clips.imag.fr/commun/bernard.cassagne/Introduction_ANSI_C.html.

[4] Delannoy (C.). -- Programmer en langage C. -- Eyrolles, 1992.

[5] Faber (F.). -- Introduction à la programmation en ANSI-C. --

http://www.ltam.lu/Tutoriel_Ansi_C/.

[6] Kernighan (B.W.) et Richie (D.M.). -- The C programming language. -- Prentice Hall,
1988, seconde édition.

[7] Léon (L.) et Millet (F.). -- C si facile. -- Eyrolles, 1987.

30