cours entier

Programmation Procédurale 

en langage C 

Cours de 1 re Année 

Dernière révision : octobre 2012 

Guillaume Rivière 

L A TEX

Avant-propos 2 

Le monde (informatique) se divise en deux catégories. . .


Pourquoi devez-vous apprendre à programmer ? 

1 Pour comprendre le monde de l’informatique 

2 Pour écrire de petits programmes (10 - 100 lignes) 

3 Pour écrire de gros programmes (1000 - 10.000 lignes) 

4 Pour savoir concevoir, rédiger, passer commande de projets 

(impossible sans connaître la réalité de la programmation) 

Principaux champs d’application qui vous concernent : 

Électronique numérique 

Robotique / Automatique 

Commande numérique 

Système d’information de l’Entreprise 

Microcontrôleur PIC1655A 

(Environnement MikroC)

Schéma des prérequis 

Avant-propos 4


Programmation de robots LEGO MINDSTORMS NXT 

1 micro-ordinateur intelligent 

4 ports d’entrée (lecture) 

4 ports de sortie (écriture) 

Différents langages 

possibles : 

C, C sharp, Ada, Java, 

MATLAB, .Net, . . . 

Capteur 

d’ultrasons 

Capteur 

tactile 

Capteur 

photosensible 

Capteur 

sonore 

Servo-moteur


Programmation de robots LEGO MINDSTORMS NXT 

Faire coopérer 2 robots 

1 robot explorateur 

1 robot ramasseur 

Photos projet de 2 élèves ESTIA


Programmation du robot NAO 

25 degrés de liberté 

58 cm de hauteur 

Vision par ordinateur 

Reconnaissance vocale 

Synthèse vocale 

Mains préhensiles 

Ordinateur embarqué 

Système Linux 

Différents langages possibles : 

C++, Python, Java, MATLAB, 

.Net, . . . 

SDK sur http://www. 

aldebaran-robotics.com


Programmation du robot KUKA 

KR6-ARC 

6 axes de rotation 

Différents langages possibles : 

KRL (C et C++ à venir)


Analyse Systémique de l’Entreprise 

Mots-clés du Système d’Information 

Intranet, Site web, Formulaires 

Réseaux, Serveurs, . . . 

Bases de données, ERP (PGI) 

GPAO, SCM, GRC, SGDT, . . .


Programmation web 

PHP, Javascript, Applets Java, ASP, JSP, Ajax, . . .


Où trouve-t-on des programmes ? 

↩→ Dans les ordinateurs : oui. . . mais pas seulement ! 

Systèmes d’exploitation, Bureautique, Navigateur web, . . . 

Bases de données, Sites web, eMails, S.I. des entreprises, . . . 

Téléphones, GPS, Avions, Voitures, Fusées, électroménager, . . . 

Opérateurs mobiles, Banques, Assurances, . . . 

Jeux vidéos, Films animés (Pixar), Météo, Géophysique, . . . 

CAO (Catia, Pro-eng), Bras robotisés, Chaînes de montage, . . . 

Reconnaissance vocale, MP3, . . . 

. . .


Un langage machine est l’ensemble des mots machines 

compréhensibles par un processeur (jeu d’instructions). 

Un programme écrit en assembleur décrit (quasiment) unes à 

unes les opérations que doit faire le processeur (JMP, CALL, ADD, 

SUB, MUL, AND, OR, NOT, CMP, MOV, PUSH, POP, JS, JI, 

JE, ...). L’écriture d’un programme en assembleur reste un travail 

laborieux et chronophage (aussi les compétences se raréfient). 

Un langage de programmation permet de décrire un programme 

à un plus haut niveau de logique, en s’astreignant (d’une grande part) 

des contraintes machines. La traduction, dans un langage machine, 

du code ainsi écrit, est assurée par un compilateur.

Différents paradigmes de programmation existent : 


Encore d’autres caractéristiques : Multi-paradigme : Python, Javascript. . . 

Compilé / Interprété / Semi-interprété Asynchrones, Temps réel. . .

Cinq générations de langages : 

Avant-propos 14


à la fin de ce cours, vous saurez : 

Conduire les itérations nécessaires pour 

écrire un programme qui fonctionne 

utiliser un compilateur et un IDE 

corriger les erreurs 

tester exécution ⇒ aboutir programme 

qui réponde au problème posé 

Connaître le langage C (norme ANSI 89) 

très grande efficacité pour tout ce qui 

concerne le développement système 

reste un des langages les plus utilisés en informatique industrielle 

Construire rapidement une interface graphique et la connecter pour 

appeler des fonctions écrites précédemment. 

Vous serez aussi capable de comprendre et de coder en Pascal, 

MatLab, Mupad, Basic, Fortran, Perl, . . . et bien sûr en C, langage 

d’application choisi car c’est un prérequis pour l’EEA

Plan 16 

1 Introduction 

2 Types de base 

3 Opérateurs 

4 Entrées/Sorties 

5 Structures de Contrôle & Boucles 

6 Fonctions 

7 Pointeurs 

8 Structures 

9 Le préprocesseur 

10 Bibliothèque standard 

11 Génie logiciel et C

Plan 17 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




1 INTRODUCTION Généralités 18 

Langage très répandu et utilisé, principalement parce que : 

Initialement lié à Unix 

Date des années 1970 (savoir commun. . .) 

Le code machine généré est rapide et compact 

Principales caractéristiques du langage C : 

Langage de programmation impérative (procédurale) 

où (presque) tout est fonction : 

a = b = 0 ; /* équivalent à a = (b = 0) ; */ 

RMQ : le ” ;” signifie la fin d’une instruction 

RMQ : les commentaires s’écrivent entre /* et */ 

Programmation structurale 

Typage faible 

Typage statique 

Langage ”bas niveau” (Manipulation mémoire, E/S, . . .)


Principaux avantages du langage C : 

Typage faible 

Travail ”bas niveau” 

Très très répandu 

Compatible avec nombreux langages et librairies 

Principaux inconvénients du langage C : 

Typage faible 

Pas de ramasse miettes 

Pas de système de gestion d’erreur 

Le langage C possède cependant un GROS défaut : il offre aux 

programmeurs un grand degré de liberté 

Philosophie du C : le programmeur sait ce qu’il fait. . . 

Donc on trouve beaucoup de bugs dans les programmes 

↩→ Conclusion : il faut de la discipline (cf. Génie Logiciel p254)


Normes : 

Livres : 

1972 : C ”K&R” 

1989 : ANSI C (American National Standards Institute) 

1999 : C99 

”Le langage C”, B. Kernighan & D. Ritchie (Dunod) : à lire absolument ! 

”Méthodologie de la programmation en langage C”, A. Braquelaire 

(Dunod) : à lire en fin de semestre 

”Programmer en langage C”, C. Delannoy (Eyrolles) 

”Le langage C”, H. Garreta. Disponible en ligne : 

http://c.developpez.com/cours/poly-c/ 

RMQ : Le langage C fut créé en 1972 par Dennies Ritchie qui travaillait 

alors au sein des laboratoires AT&T Bell Labs aux USA

1 INTRODUCTION Champs d’application possibles 21 

Le langage C est notamment très utilisé pour : 

Programmation ”bas niveau” 

Systèmes embarqués 

Programmation système (ex : Linux en C à 96%, Windows, MacOS) 

Programmation réseaux 

Traitement d’images (ex : Vision par ordinateur) 

Cartes microprogrammées 

Logiciels (ex : Oracle, MySQL, Apache, Firefox, Word, Excel, 

Photoshop, Gimp, . . .et pour ne citer qu’eux, sont écrits en C/C++) 

Exemples de bibliothèques logicielles écrites en C : 

OpenGL 

SDL 

GTK 

OpenCV 

. . .

1 INTRODUCTION Cursus ESTIA 22 

Langages inspirés du C (extensions) : 

C++ (Bjarne Stroustrup, 1979) 

Objective C (1983, Très utilisé par Apple) 

C# (Microsoft, 2001) 

Principaux langages reprenant la syntaxe du C : 

C++ 

PHP (Rasmus Lerdorf, 1994) 

Java (Sun Microsystems, 1996 / Oracle, 2009) 

Javascript (Brendan Eich, Netscape/Mozilla, 1995) 

C# 

. . .

1 INTRODUCTION 1 re Année ESTIA 23 

→ Vous êtes issus de parcours différents 

1 Jamais programmé ? 

2 Déjà programmé, mais dans d’autres langages ? 

(Pascal, Fortran, Ada, OCaml, Python, VB, VBA, . . .) 

3 Déjà programmé en C ? 

4 Déjà programmé en C++, Java, C# ou PHP ? ? ? 

↩→ La programmation reste d’une manière générale un 

apprentissage long et difficile (de l’ordre de plusieurs années. . .) 

↩→ Comment apprendre ? 

Commencer par de petits programmes basiques pour évoluer 

plus tard vers des plus gros (Interfaces Graphiques, Scènes 3D, 

Échanges réseaux, Temps réel, Son, Image, Vidéo, Webcam, Tactile, 

Smartphones, GPS, SMS, emails, DB, Sécurité, Cryptage, . . .). 

⇒ Cet apprentissage commence dès maintenant

1 INTRODUCTION Programmation en 1 re Année ESTIA 24 

1 ER SEMESTRE 

Programmation Procédurale 

8h Cours 

8h TD 

10h TP + 2h Travail Personnel 

Contrôle continu par QCM 

TD : 

⋆ G1, G3 : N.Takouachet 

⋆ G2, G4 : G.Rivière 

TP : 

⋆ G1, G3 : N.Takouachet, J.M.Cieutat 

⋆ G2, G4 : G.Rivière, N.Ghouaiel 

Développement Rapide d’Interface 

12h TP 

Évaluation 

2 E SEMESTRE 

Projet Génie Informatique 

12h TP + 8h Travail Personnel

1 INTRODUCTION Écrire un programme 25 

Structure générale d’un programme C : 

1 Inclusion de fichiers (déclarations, prototypes, . . .) 

2 Définition de macros 

3 Définition de types et de prototypes de fonctions 

4 Déclaration de variables GLOBALES 

5 Code des fonctions

1 INTRODUCTION Premier programme 26 

Exemple 1 : l’incontournable 

helloworld.c 

1 #include 

2 

3 /* Fonction principale */ 

4 int main () { 

5 

6 printf ("Hello World!!!\n") ; 

7 

8 return 0 ; 

9 } 

10 /* Fin du programme */ 

Un programme doit TOUJOURS comporter une fonction ”main()” 

↩→ Cette fonction ”principale” du programme est particulière 

⇒ C’est le ”point de départ” du programme ! 

RMQ : ’\n’ est le caractère ”retour chariot”, ”retour à la ligne” 

RMQ : Tout programme retourne une valeur représentant un code 

d’erreur (d’exécution). Par convention, 0 signifie ”exécution normale” 

(pas d’erreur)

1 INTRODUCTION Deuxième programme 27 

Exemple 2 : chaînes de caractères 

votrenom.c 

1 #include /* Declaration de printf() et scanf() */ 

2 #include /* Declaration de strlen() */ 

3 


5 char name[256] ; /* Declaration d’un tableau de 256 caracteres */ 

6 

7 printf ("Donnez votre nom : ") ; 

8 scanf ("%s", name) ; 

9 

10 printf ("%s, votre nom comporte %d lettres.\n", name, strlen(name)) ; 

11 

12 return 0 ; 

13 } 

Exemples de 2 exécutions :

1 INTRODUCTION Troisième programme 28 

Exemple 3 : conditionnelle 

parite.c 

1 #include /* Declaration de printf() et scanf() */ 

2 


4 int n ; 

5 

6 printf ("Donnez un nombre entier : ") ; 

7 scanf ("%d", &n) ; 

8 

9 if ((n % 2) != 0) /* Variante : if (n & 1) */ 

10 printf ("Le nombre %d est impair.\n", n) ; 

11 else 

12 printf ("Le nombre %d est pair.\n", n) ; 

13 

14 return 0 ; 

15 } 

10 mod 2 = 0 

9 mod 2 = 1 

pair={2n|n ∈ Z} 

impair={2n + 1|n ∈ Z} 

n pair 

⇔ ∃i tq n = 2i 

n impair 

⇔ ∃i tq n = 2i + 1 


Page support 29 

http://www.guillaumeriviere.name/estia/C/ 

Supports de cours 

Pour écran 

Pour imprimante 

Par chapitre 

Exemples du cours 

Fichiers sources .c 

Fichiers exe pour Windows 

Archive zip 

Exercices 

Énoncés de TP (en ligne) 

Énoncés de TD (pdf) 

17 exercices pour s’entraîner 

Ressources web 

Cours, Tutoriels, . . . 

Manuels 

Outils (GCC, Notepad++, . . .)

1 INTRODUCTION Quatrième programme 30 

Exemple 4 : paramètres en ligne de commande 

addition.c 

1 #include /* Declaration de printf() et fprintf() */ 

2 #include /* Declaration de exit() */ 

3 

4 int main (int argc, char *argv[]) { 

5 int a, b, c ; 

6 

7 /* Verification du nombre d’arguments */ 

8 if (argc != 3) { 

9 fprintf (stderr, "Usage: %s \n", argv[0]) ; 

10 exit (1) ; /* Arret sur erreur */ 

11 } 

12 

13 /* Recuperation des arguments */ 

14 a = atoi (argv[1]) ; 

15 b = atoi (argv[2]) ; 

16 

17 /* Calcul du resultat */ 

18 c = a + b ; 

19 

20 /* Affichage du resultat */ 

21 printf ("La somme de %d et %d est %d\n", a, b, c) ; 

22 

23 return 0 ; /* Sortie normale */ 

24 } 

RMQ : Commenter correctement le code est important

1 INTRODUCTION Quatrième programme 31 

Exemples de 3 exécutions : 

→ Le passage des arguments se fait au moment de l’appel du 

programme 

→ Dans notre programme, nous exigeons que le nombre 

d’arguments soit exactement égal à 3 

RMQ : Le premier argument (argv[0]) est le nom du programme 

RMQ : Les arguments sont des chaînes de caractère 

↩→ La variable argv[] est un tableau de chaînes de caractères 

⇒ La fonction atoi() calcule la valeur entière à partir d’une chaîne 

de caractères

1 INTRODUCTION Cinquième programme 32 

Exemple 5 : une calculatrice à deux opérandes 

calculatrice.c 

1 #include 

2 #include 

3 

4 void usage (char *program) { 

5 fprintf (stderr, "Usage: %s \n", program) ; 

6 fprintf (stderr, " with operator in {+,-,x,/}\n") ; 

7 } 

8 


10 double v1, v2, res ; 

11 char op ; 

12 


14 if (argc != 4) { 

15 usage (argv[0]) ; 


17 } 

18 

19 /* Recuperation des arguments */ 

20 v1 = atof (argv[1]) ; 

21 v2 = atof (argv[3]) ; 

22 op = argv[2][0] ; 

23 

24 /* Calcul du resultat */ 

25 switch (op) { 

26 case ’+’: 

27 res = v1 + v2 ; 

28 break ; 

29 case ’-’:

1 INTRODUCTION Cinquième programme 33 

calculatrice.c (suite et fin) 

30 res = v1 - v2 ; 

31 break ; 

32 case ’x’: 

33 res = v1 * v2 ; 

34 break ; 

35 case ’/’: 

36 res = v1 / v2 ; 

37 break ; 

38 default: 

39 usage (argv[0]) ; 


41 } 

42 

43 /* Affichage du resultat */ 

44 printf ("%.1f %c %.1f = %.1f\n", v1, op, v2, res) ; 

45 

46 return 0 ; /* Sortie normale */ 

47 } 


1 INTRODUCTION Sixième programme 34 

Exemple 6 : tableaux, répétitions, E/S 

somme.c 

1 #include 

2 #define TAILLE_MAX_TAB 20 

3 

4 int tab[TAILLE_MAX_TAB] ; /* Declaration d’un tableau global d’entiers */ 

5 int somme_tab (int n) ; /* Declaration d’une fonction */ 

6 

7 /** 

8 * Fonction principale 

9 */ 


11 int i, n ; /* Declaration de variables locales */ 

12 

13 /* Boucle d’entree : lecture taille du tableau tab */ 

14 do { 

15 printf ("Donnez un entier entre 2 et %d : ", TAILLE_MAX_TAB-1) ; 

16 scanf ("%d", &n) ; 

17 } while (n=TAILLE_MAX_TAB) ; 

18 

19 /* Boucle : lecture des n entiers */ 

20 for (i=0 ; i

1 INTRODUCTION Sixième programme 35 

somme.c (suite et fin) 

30 

31 /** 

32 * Fonction : somme des n premiers termes de tab 

33 */ 

34 int somme_tab (int n) { 

35 int res = 0 ; /* Declaration d’une variable initialisee avec 0 */ 

36 

37 while (n-- > 0) /* Ajout des n entiers */ 

38 res += tab[n] ; 

39 

40 return res ; /* Retour du resultat */ 

41 } 

Exemple d’exécution : 

Exercice : 

Modifier le programme pour calculer 

la moyenne (en plus de la somme) 

Pour ce faire, vous créerez une 

nouvelle fonction : 

double moyenne tab (int n) ;

1 INTRODUCTION Septième programme 36 

Exemple 7 : types structurés, déclaration de type, E/S 

complexes.c 

1 #include 

2 #define SQRT2 1.414213562 

3 

4 /** Declaration d’une nouvelle structure de donnees */ 

5 struct complexe { 

6 double real ; /* Partie reelle */ 

7 double img ; /* Partie imaginaire */ 

8 } ; 

9 

10 /** Declaration d’un nouveau type : les complexes */ 

11 typedef struct complexe complexe ; 

12 

13 /** Fonction : ajout de deux nombres complexes */ 

14 complexe complexe_ajouter (complexe c1, complexe c2) { 

15 complexe resultat = c1 ; 

16 

17 resultat.real += c2.real ; 

18 resultat.img += c2.img ; 

19 

20 return resultat ; 

21 } 

22 

23 /** Fonction principale */ 


25 complexe a, b, c ; 

26 

27 /* Initialisation du complexe a */ 

28 a.real = SQRT2 ; 

29 a.img = SQRT2 ;

1 INTRODUCTION Septième programme 37 

complexes.c (suite et fin) 

30 

31 /* Initialisation du complexe b : saisie de 2 valeurs au clavier */ 

32 printf ("Partie reelle : ") ; 

33 scanf ("%lf", &b.real) ; 

34 printf ("Partie imaginaire : ") ; 

35 scanf ("%lf", &b.img) ; 

36 

37 /* Calcul et affichage de c = a + b */ 

38 c = complexe_ajouter (a, b) ; 

39 printf ("La somme est (%f, %f)\n", c.real, c.img) ; 

40 

41 return 0 ; 

42 } 


Exercice : 

Modifier le programme pour que 

(comme fait pour b) le complexe a 

soit lui aussi initialisé par des valeurs 

entrées au clavier par l’utilisateur 

(plutôt qu’il soit initialisé à ( √ 2; √ 2))

1 INTRODUCTION Huitième programme 38 

Exemple 8 : accès fichiers 

copier.c 

1 #include /* fprintf(), fopen(), getc(), putc(), fclose() */ 

2 #include /* exit() */ 

3 #include /* strcmp() */ 

4 

5 /* Programme equivalent a la commande copy (sans les arguments optionnels). 

6 * NB : copy permet la copie d’un fichier dans un autre. */ 


8 FILE *fsrc, *fdst ; 

9 char c ; 

10 

11 /* Validation des arguments en ligne de commande */ 

12 if (argc != 3 || strcmp(argv[1], argv[2]) == 0) { 


14 exit (1) ; 

15 } 

16 

17 /* Ouverture des 2 fichiers (source et destination) */ 

18 fsrc = fopen (argv[1], "r") ; 

19 if (fsrc == NULL) { 

20 fprintf (stderr, "Error: cannot open %s in read mode\n", argv[1]) ; 

21 exit (-1) ; 

22 } 

23 

24 fdst = fopen (argv[2], "w") ; 

25 if (fsrc == NULL) { 

26 fprintf (stderr, "Error: cannot open %s in write mode\n", argv[2]) ; 

27 fclose (fsrc) ; 

28 exit (-2) ; 

29 }

1 INTRODUCTION Huitième programme 39 

copier.c (suite et fin) 

30 

31 /* Copie caractere par caractere */ 

32 while ((c = getc (fsrc)) != EOF) /* EOF = fin de fichier */ 

33 putc (c, fdst) ; /* fprintf (fdst, "%c", c) ; */ 

34 

35 /* Fermeture des deux fichiers */ 

36 fclose (fsrc) ; 

37 fclose (fdst) ; 

38 

39 printf ("Done.\n") ; 

40 return 0 ; 

41 } 


Exercice : 

Modifier le programme pour compter 

au passage le nombre de caractères 

recopiés et en informer l’utilisateur. 

Les espaces seront ignorés dans ce 

comptage : 

int cpt = 0 ; 

/* ... */ 

if (c != ’ ’) 

cpt = cpt + 1 ; 

/* ... */ 

printf ("Caracteres : %d\n", cpt) ;

1 INTRODUCTION Mots réservés 40 

RMQ : De nombreux symboles structurent le langage C 

; , {} () [] -> . ! ∼ ++ −− = ∗ / % + − < = > == ! = 

> & ∧ | && || ? : += −= ∗= /= %= &= ∧= |= = 

RMQ : Certains mots sont réservés (”mots clés”) 

Ces mots particuliers font parti du langage C 

Leur emploi est précis et régit par des règles 

Liste des mots clés réservés en C : 

return sizeof extern static const 

char int float double void 

short long signed unsigned typedef 

struct enum if else switch 

case default break continue goto 

for while do #include #define 

#undef #ifdef #ifndef #else #endif 

(Non exhaustif, mais assez complet)

1 INTRODUCTION Programmer 41 

3 grandes étapes : coder, compiler, exécuter 

TRÈS nombreuses 

itérations. . . . . . 

1 CODER 

Écriture en langage C par un programmeur 

Le code source définit le comportement du programme 

⇒ Fichiers sources lisibles par un humain (ASCII) 

2 COMPILER 

Lecture des fichiers sources par un compilateur 

Analyse du code C, traduction en code machine 

Détection d’erreur (langage, bibliothèques, . . .) 

⇒ Un fichier ”exécutable” est généré (binaire) 

3 EXÉCUTER 

Exécution des instructions sur le processeur processus 

Tests : le programme répond-il au besoin, au cahier des charges ? 

Tests : le programme fonctionne-t-il correctement ? Fiabilité ? 

↩→ corriger le code source, debbugage, . . . 

4 UTILISER / EXPLOITER / DIFFUSER (?)

1 INTRODUCTION Programmer (Itération 1) 42 

Exemple : Écrire un programme qui permet d’évaluer la fonction 

F(x) = pour des valeurs de x données par l’utilisateur. 

√ x 

x 2 −2x−3 

0 RÉFLÉCHIR ASD 

1 CODER 

evaluer.c 

2 COMPILER gcc -Wall -ansi evaluer.c 


2 double x ; 

3 

4 /* Demander la valeur de x */ 

5 printf ("Donnez x : ") ; 

6 scanf ("%lf", &x) ; 

7 

8 /* Calculer F(x) */ 

9 F = sqrt (x) / (x*x - 2*x - 3) ; 

10 

11 /* Afficher le resultat */ 

12 printf ("F(%f)=%d\n", x, F) ; 

13 

14 return 0 ; 

15 } 

Warnings ⇒ Les fonctions printf(), 

scanf() et sqrt() n’ont pas été déclarées 

Error ⇒ La variable F n’a pas été déclarée


1 CODER 

→ Inclusion du fichier d’entête stdio.h où les fonctions printf() et 

scanf() sont déclarées 

→ Inclusion du fichier d’entête math.h où la fonction sqrt() est déclarée 

→ Enfin, déclaration de la variable F 

evaluer.c 

1 #include 

2 #include 

3 


5 double x ; 

6 double F ; 

7 



10 scanf ("%lf", &x) ; 

11 


13 F = sqrt (x) / (x*x - 2*x - 3) ; 

14 


16 printf ("F(%f)=%d\n", x, F) ; 

17 

18 return 0 ; 

19 } 

2 COMPILER 

Warning ⇒ Ligne 16 : le type attendu pour 

le 3 e argument de printf() est int mais F 

est de type double


1 CODER 

→ Changement du %d en %f 

dans la chaîne de formatage 

de printf() 

evaluer.c 

1 #include 

2 #include 

3 


5 double x ; 

6 double F ; 

7 



10 scanf ("%lf", &x) ; 

11 


13 F = sqrt (x) / (x*x - 2*x - 3) ; 

14 


16 printf ("F(%f)=%f\n", x, F) ; 

17 

18 return 0 ; 

19 } 

2 COMPILER 

Échec lors de l’édition des liens ⇒ Le 

code machine de la fonction sqrt() est 

introuvable 

↩→ Inclure ne suffit pas 

2 (RE)COMPILER 

→ Ajout de l’option de compilation -lm pour 

lier la librairie mathématique qui fournit, 

parmi d’autres, le code machine de la 

fonction sqrt() 

↩→ gcc -Wall -ansi -lm evaluer.c


3 EXÉCUTER 

→ Le nom par défaut de l’exécutable généré par GCC est a.exe 

↩→ Soit renommer le fichier, soit ajouter l’option -o à la commande de 

compilation : gcc -Wall -ansi -lm evaluer.c -o evaluer.exe 

Problème lorsque l’utilisateur entre x = 3 

↩→ En effet, 3 est une racine du polynôme 

x 2 − 2x − 3 ce qui entraîne une division par 0 

⇒ Solution 1 : 

Vérifier au préalable que x n’est pas une 

racine du polynôme 

(programmation défensive) 

⇒ Solution 2 : 

Évaluer le dénominateur et vérifier qu’il est 

non nul avant de procéder à la division


1 CODER 

evaluer.c 

1 #include 

2 #include 

3 


5 double x ; 

6 double F, N, D ; 

7 



10 scanf ("%lf", &x) ; 

11 

12 /* Calculer le denominateur */ 

13 D = (x*x - 2*x - 3) ; 

14 

15 if (D != 0.) { 

16 N = sqrt (x) ; 

17 F = N / D ; 

18 


20 printf ("F(%f)=%f\n", x, F) ; 

21 } 

22 else { 

23 /* Afficher un message */ 

24 printf ("Calcul impossible : " 

25 "division par zero\n") 

; 

26 } 

27 return 0 ; 

28 } 

2 COMPILER 

3 EXÉCUTER 

fin

1 INTRODUCTION La compilation 47 

La compilation C comporte 

3 phases principales 

Pour chaque fichier source 

(1a) Traitement du fichier 

source par le 

préprocesseur C 

(1b) Compilation et 

génération du code cible 

(2) Édition des liens 

Réunit les fichiers cibles, 

puis ajoute les fonctions 

issues des bibliothèques, 

pour créer un seul fichier 

”exécutable” autonome

1 INTRODUCTION Les outils nécessaires 48 

Pour développer 

1 éditeur de texte (BlocNote, NodePad++, Emacs, . . .) 

1 compilateur C (MinGW-GCC, . . .) 

1 invite de commandes 

Pour compiler depuis l’invite de commande : 

gcc -Wall -ansi helloworld.c -o helloworld.exe 

Paramètres : 

Autres paramètres utiles : 

-Wall = warning all (OBLIGATOIRE) 

-ansi = respecter la norme ANSI C 

-o = nom du fichier produit 

-L : répertoires où se trouvent des nouvelles bibliothèques (.lib) 

-l : nom des bibliothèques à utiliser lors de l’édition des liens 

(par exemple : -lm -lopengl32 -lpthread -lGid32) 

-I : répertoires où se trouvent des fichiers d’entête (.h)

1 INTRODUCTION Compilation séparée 49 

Il est possible d’écrire les fonctions d’un programme dans différents 

fichiers (plutôt que dans un seul) 

Permet de répartir le code dans de multiples fichiers plus petits 

(plutôt qu’un seul gros fichier de 10 6 lignes) 

→ lisibilité et maintenabilité 

Permet de réutiliser ces fichiers dans d’autres programmes pour 

réutiliser les fonctions déjà écrites (principe de modularité) 

→ gain de temps et coûts diminués 

Permet de ne recompiler que partiellement le code en cas de 

modification (Sur un gros programme : ne pas perdre 1h de 

compilation juste pour une fonction modifiée) 

→ temps 

Le mécanisme de la compilation séparée permet cela 

gcc -c -Wall -ansi main.c 

gcc -c -Wall -ansi droites.c 

gcc main.o droites.o -lm -o mesures.exe

1 INTRODUCTION Makefile 50 

Un fichier Makefile décrit les dépendances entre les différents 

fichiers sources d’un projet 

Les commandes de compilation seront invoquées séparément 

Les dates systèmes des fichiers indiqueront les fichiers à recompiler 

Un ou des fichiers seront recompilés selon les dépendances (en 

cascade) 

1 default: fic1.o fic2.o main.o 

2 gcc -o prog.exe fic1.o fic2.o 

main.o 

3 

4 main.o: fic1.h fic2.h main.c 

5 gcc -c -Wall -ansi main.c 

6 

7 fic1.o: fic1.h fic1.c 

8 gcc -c -Wall -ansi fic1.c 

9 

10 fic2.o: fic2.h fic2.c 

11 gcc -c -Wall -ansi fic2.c 

1 En invoquant la commande make (ou 

make default), on consulte la tâche 

default 

2 Elle implique que les tâches fic1.o 

fic2.o et main.o soient à jour 

3 Si ce n’est pas le cas, alors ces tâches 

sont effectuées 

4 Effectuer une tâche consiste à exécuter la (ou les) ligne(s) qui suivent et 

qui commençent par un saut de tabulation

1 INTRODUCTION Makefile 51 

Exemple de Makefile simple 

et générique 

1 Invoquer la commande make 

provoque la compilation du projet 

Makefile 

1 # Makefile (simple) generique 

2 

3 # Variables a modifier (projet en cours) 

4 EXEC = mesures.exe 

5 SRC = main.c droites.c 

6 LIB = -L. -lm 

7 INC = -I. 

8 

9 # Variables immuables (ne pas modifier) 

10 CC = gcc 

11 CFLAG = -O -c -Wall -ansi $(INC) 

12 OFLAG = -O -o $(EXEC) 

13 OBJ = $(SRC:.c=.o) 

14 

15 default: $(OBJ) 

16 $(CC) $(OFLAG) $(LIB) $(OBJ) 

17 

18 .c.o: 

19 $(CC) $(CFLAG) $< 

20 

21 clean: 

22 del *.o *˜ core #*# 

23 

24 # Fin du Makefile 

2 Invoquée de nouveau, la 

commande make ne déclenche rien 

3 Si main.c a changé, alors il est 

recompilé (seul) 

4 Invoquer make clean nettoie les 

fichiers de compilation (.o)

1 INTRODUCTION Environnements de développement 52 

Code, Compilation, Exécution : tout dans la même fenêtre


Principaux IDE gratuits permettant de développer en C : 

(Integrated Development Environment) 

Code::Blocks 

Visual C++ 2010 

wxDev-c++ 

Xcode 

Eclipse 

← (version ”Express” gratuite) 

← ESTIA 

En savoir plus : http://c.developpez.com/compilateurs/


ECLIPSE 

Initié par IBM (Initialement dédié à Java) 

Passage en logiciel libre en 2001 (Eclipse Foundation) 

IDE extensible, universel et polyvalent 

Multi-plateforme (Windows, Linux, Mac, . . .) 

Langages : Java, C/C++, C#, Ada, Python, Pascal, Cobol. . . 

Version Projets Lignes Date 

1.0 nov. 2001 

3.0 juin 2004 

3.3 Europa 21 17.10 6 juin 2007 

3.5 Galileo 33 24.10 6 juin 2009 

3.6 Helios 77 juin 2010 

3.7 Indigo juin 2011 

La version actuelle d’Eclipse propose 12 paquetages : 

CDT (C/C++ Development Tools) 

JDT (Java Development Tools) 

ADT (Ada Development Tools) 

. . . http://www.eclipse.org


ECLIPSE

1 INTRODUCTION Recommandations 56 

→ Ce n’est pas en regardant un forgeron que l’on apprend à forger 

(canfere un proverbe bien connu) 

→ Il en va de même en programmation : 

Ce n’est pas parce que vous aurez compris le code d’un 

programme (exemples, corrections, . . .) que vous saurez 

programmer 

Ce n’est pas non plus en recopiant des programmes qu’on 

apprend à programmer (même si c’est un bon début) 

Vous saurez programmer lorsque vous serez capables d’écrire 

un programme ”from scratch”, c.à.d. en partant d’un fichier vide 

Commencer par de petits programmes est le mieux pour 

apprendre (Par exemple réécrire helloworld.c depuis zéro) 

Essayer de modifier et/ou compléter le comportement des 

programmes donnés en exemple est aussi un bon réflexe pour 

apprendre




Pour écran 


Par chapitre 




Archive zip 

Exercices 






Manuels 


Plan 58 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




2 TYPES DE BASE Introduction 59 

Un modèle de données comporte 2 aspects indissociables : 

1 Les valeurs pouvant être attribuées aux objets 

2 Les opérations sur les données 

En C, il existe peu de modèles de données. On trouve : 

les types de base (nombres entiers et réels) 

les tableaux 

les enregistrements 

les pointeurs 

Dans ce chapitre on ne traite que des types de base et des tableaux. 

Les pointeurs et les enregistrements (ou structures) font l’objet de 

deux chapitres dédiés

2 TYPES DE BASE Variables 60 

21 

Variables 

Une variable = un nom, un type, une valeur et un espace mémoire 

Le nom d’une variable commence soit par une lettre, soit par un 

underscore. Les autres caractères peuvent aussi comporter des 

chiffres. 

Exemples de noms valides : i, Maximum, 

3 X, n1, n2, N, TAILLE 

Il y a deux principales classes de types : 

1 Les nombres entiers 

char (8 bits) 

int (16 ou 32 bits selon l’architecture sizeof()) 

2 Les nombres réels 

float (32 bits) → IEEE754 simple précision 

double (64 bits) → IEEE754 double précision

2 TYPES DE BASE Nombres entiers 61 

22 

Variables entières 

→ Représentation binaire des entiers (base 2) : 

Exemples : 

5 (10) = 1×2 2 + 0×2 1 + 1×2 0 = 101 (2) 

16 (10) = 1×2 4 + 0×2 3 + 0×2 2 + 0×2 1 + 0×2 0 = 10000 (2) 

43 (10) = 32 + 8 + 2 + 1 = 1×2 5 + 1×2 3 + 1×2 1 + 1×2 0 = 101011 (2) 

L’espace en mémoire est limité (fini) ⇒ discrétisation de N et Z 

Sur une zone mémoire de n bits, on peut coder ces intervalles : 

Entiers naturels : [ 0 ; 2 n − 1 ] 

Entiers relatifs : [ −2 n−1 ; 2 n−1 − 1 ] 

Les règles mathématiques : pas toujours valides en informatique 

Ainsi, la règle ∀n ∈ N ∃p ∈ N tq p = n + 1 est fausse 

2 unsigned char i, j ; 

3 

4 i = 255 ; 

5 j = i + 1 ; 

6 

7 /* j vaut 0 */ 

7 6 5 4 3 2 1 0 

1 1 1 1 1 1 1 1 i 255 

+ 0 0 0 0 0 0 0 1 + 1 

1 0 0 0 0 0 0 0 0 j 0

2 TYPES DE BASE Nombres entiers 62 

RMQ : Différents qualificatifs existent pour les types : 

signed, unsigned (réservé aux entiers) 

short (réservé aux entiers) et long (pour int et double) 

Table des types entiers possibles : 

Type Abrégé Octets Bits Intervalle 

signed char char 1 8 [−128; 127] 

signed short int short 2 16 [−32.768; 32.767] 

signed int int 2 ou 4 

signed long int long 4 32 [−2.147.483.648; 2.147.483.647] 

signed long long int long long 8 64 [−2 63 ; 2 63 − 1] 

unsigned char 1 8 [0; 255] 

unsigned short int unsigned short 2 16 [0; 65.535] 

unsigned int 2 ou 4 

unsigned long int unsigned long 4 32 [0; 4.294.967.295] 

unsigned long long int unsigned long long 8 64 [0; 2 64 − 1] 

La plupart des architectures codent les 

types signed int et unsigned int 

sur 4 octets. 

2 63 = 9, 223372 × 10 18 

2 64 = 1, 84467441 × 10 19

2 TYPES DE BASE Nombres réels 63 

23 

Variables réelles (float et double) 

En C les nombres réels sont représentés selon la norme IEEE754 

simple précision (type float) et double précision (type double) : 

(−1) S × 1,m × 2 E−d 

d = 2 e−1 − 1 

float double long double 

avec : 32 bits 64 bits 80 bits 

S Signe 1 bit 1 bit 1 bit 

m Mantisse 23 bits 52 bits 64 bits 

E Exposant e = 8 bits e = 11 bits e = 15 bits 

d Décalage d = 127 d = 1023 d = 16.383 

Exemple : 

S = 0 

E = 10000001 = 129 

m = 01000000000000000000000 

1,m = 1,01000000000000000000000 = 1 × 2 0 + 0 × 2 −1 + 1 × 2 −2 = 1 + 0 + 0, 25 = 1, 25 

(−1) 0 × 1,m × 2 129−127 = 1 × 1, 25 × 2 2 = 5, 0


Exemple : 

S = 0 

E = 10000001 = 129 

m = 01100000000000000000000 

1,m = 1,01100000000000000000000 = 1 × 2 0 + 0 × 2 −1 + 1 × 2 −2 + 1 × 2 −3 

= 1 + 0 + 0, 25 + 0, 125 

= 1, 375 

(−1) 0 × 1,m × 2 129−127 = 1 × 1, 375 × 2 2 = 5, 5 

Valeurs spéciales : 

+0 et -0 : il existe deux zéros ! 

Quand E = 0 et m = 0 

+Inf et -Inf : les deux infinis +∞ et −∞ 

Qd E = 2 e − 1 et m = 0 

NaN (Not a Number) : du à une erreur de calcul (division par 0, . . .) 

Qd E = 2 e − 1 et m ≠ 0


Pour les mêmes raisons qui font que les ensembles N ou Z sont des 

ensembles finis en informatique, l’ensemble R est lui aussi fini : 

1 Ainsi, il existe un nombre réel maximum et un nombre réel minimum 

(ensemble borné) pour chacun des types float et double 

2 Et la règle mathématique ∀ x, y ∈ R ∃ z ∈ R tq x < z < y 

n’est pas vérifiée 

Par exemple : 

Plus grand nombre 

float : 3, 40282346 × 10 38 

double : 1, 7976931348623157 × 10 308 long double : 3, 4 × 10 4932 

Nombre juste après 1.0 

float : 1.000000119209289550781250000 ≈ 1.00000012 

double : 1.0000000000000002220446049250313080847263336181640625000 

≈ 1.000000000000000222 

Nombre juste avant 1.0 

float : 0.999999940395355224609375000 ≈ 0.99999994 

double : 0.9999999999999998889776975374843459576368331909179687500 

≈ 0.999999999999999889


Ainsi, sur machine, l’ensemble des réels n’est pas dense. 

Exemple : 

4 float x ; 

5 

6 x = 38.0 ; 

7 printf ("x vaut %.15lf\n", x) ; 

8 

9 x = x + 0.05 ; 

10 printf ("x vaut %.15lf\n", x) ; 

↩→ Toujours préférer les double car plus précis que float ! 

Mais occupent 64 bits contre 32 bits. . . 

⇒ trouver compromis entre précision et occupation mémoire 

Par exemple OpenGL utilise triplet de float pour coordonnées 3D 

RMQ : Le test d’égalité se révèle donc dangeureux ! 

Par exemple while(x != 95.005) peut ne jamais s’arrêter 

Il sera préférable de tester : 

while (fabs (x - 95.005) < epsilon)


Proposition : 

La représentation (en virgule flottante) des nombres réels (sur un 

espace discret) selon la norme ieee754 est : 

plus dense dans l’intervale [0 ; 1] (densité très forte) 

que dans l’intervalle [1 ; 2] (densité moyenne) 

et que dans l’intervalle [2 ; +∞] (densité faible). 

Lemme 1 : 

∀ m : 1 ≤ 1,m < 2 

Lemme 2 : 

E < 127 ⇔ 2 E−127 < 1 

Donc si E < 127 alors ∀ m : 1,m × 2 E−127 < 1,m 

Lemme 3 : 

E > 127 ⇔ 2 E−127 > 1 

Donc si E > 127 alors ∀ m : 1,m × 2 E−127 > 1,m


Démonstration : 

Considérons la fonction 2 X : 

Bien entendu, cette courbe n’est pas à l’échelle ! 

2 64 = 1, 84467441 × 10 19 = 18.446, 7441 millions de milliards 

2 127 = 1, 70141183 × 10 38


Après changement de repère avec E = X + 127 :


Après multiplication par 1,m : 

Si E < 127 alors ∀ m : 1,m × 2 E−127 < 1,m (lemme 2) 

Si E > 127 alors ∀ m : 1,m × 2 E−127 > 1,m (lemme 3)


Or ∀ m : 1 ≤ 1,m < 2 (lemme 1)


mantisse sur 23 bits : 2 23 = 8.388.608 ≈ 8, 4 × 10 6 (8,4 millions) 

mantisse sur 52 bits : 2 52 ≈ 4, 5 × 10 15 ≈ 4.503.599 × 10 9 (4,5 millions de milliards)

2 TYPES DE BASE Les tableaux 73 

24 

Les tableaux 

Tableau = une collection de variables, du même type enregistrées, 

consécutivement en mémoire. 

Un tableau est identifié par son nom (par exemple A) 

Un tableau est caractérisé par le type des éléments qu’il stocke 

(par exemple des int) 

Un tableau est caractérisé par sa taille (A est de taille N) 

⇒ En mémoire N cases consécutives seront réservées 

⇒ Chaque case permet de stocker un int 

⇒ La longueur de l’espace mémoire est N*sizeof(int) octets 

L’opérateur [] permet d’accéder aux éléments du tableaux 

⇒ A[i] est la i-ème case du tableau 

Les tableaux sont toujours indicés à partir de 0 

⇒ La première case du tableau est donc A[0] 

⇒ La dernière case du tableau est donc A[N-1]


Exemple 1 : Déclaration d’un tableau de 3 int : 

4 int T[3] ; 

5 

6 T[0] = 10 ; 

7 T[1] = 20 ; 

8 T[2] = 30 ; 

sizeof(int) → 4 octets 

3 * sizeof(int) → 12 octets (96 bits) 

T occupera 12 octets (consécutifs) en mémoire 

Exemple 2 : Déclaration d’un tableau de 6 octets 

4 int i ; 

5 char T[6] ; /* 6 octets */ 

6 

7 T[0] = 1 ; 

8 for (i=1 ; i


RMQ : Les chaînes de caractères sont représentées par des 

tableaux de char 

La taille du tableau doit être suffisante pour accueillir tous les caractères 

(du mot, de la phrase, du texte, . . .) 

La fin d’une chaîne est marquée par le caractère ’\0’ 

↩→ La taille minimum du tableau est donc TOUJOURS : 

chaine.c 

1 #include 

2 


4 char nom[10] ; 

5 

6 nom[0] = ’R’ ; 

7 nom[1] = ’i’ ; 

8 nom[2] = ’t’ ; 

9 nom[3] = ’c’ ; 

10 nom[4] = ’h’ ; 

11 nom[5] = ’i’ ; 

12 nom[6] = ’e’ ; 

13 nom[7] = ’\0’ ; 

14 

15 printf ("Nom : %s\n", nom) 

; 

16 return 0 ; 

17 } 

(nombre de caractères à stocker) + 1 

Espace alloué en mémoire : 

↩→ Ici, taille max de la chaîne = 9

2 TYPES DE BASE Caractères 76 

25 

Les caractères 

Attention, car on pense souvent que type char ⇔ caractère 

Mais un char c’est un nombre entier ! (sur 1 octet) 

En fait, chaque caractère est représenté par un nombre . . . 

Code ASCII = American Standard Code for Information Interchange 

De 0 à 31 : caractères non imprimables (caractères de contrôle) 

De 48 à 57 : les chiffres (caractères numériques) 

De 65 à 90 : les caractères alphabétiques en majuscule 

De 97 à 122 : les caractères alphabétiques en minuscule 

Autres : caractères de ponctuation (33-47, 58-64, 91-96, 123-126) 

Table ASCII 128 (1961 - normalisation ANSI en 1986) 

de 0 à 127 

langue anglaise, pas de caractères accentués 

Table ASCII 256 “étendue”(ex : Latin-1 en 1987 pour l’Europe occidentale) 

de 0 à 255 (la partie 128-255 peut varier selon la plateforme)

2 TYPES DE BASE Extrait de la table ASCII 77 

CODE caractère CODE caractère CODE caractère CODE caractère CODE caractère 

8 \b 48 0 68 D 88 X 108 l 

9 \t 49 1 69 E 89 Y 109 m 

10 \n 50 2 70 F 90 Z 110 n 

13 \r 51 3 71 G 91 [ 111 o 

32 espace 52 4 72 H 92 \ 112 p 

33 ! 53 5 73 I 93 ] 113 q 

34 ” 54 6 74 J 94 ∧ 114 r 

35 # 55 7 75 K 95 115 s 

36 $ 56 8 76 L 96 ‘ 116 t 

37 % 57 9 77 M 97 a 117 u 

38 & 58 : 78 N 98 b 118 v 

39 

′ 

59 ; 79 O 99 c 119 w 

40 ( 60 < 80 P 100 d 120 x 

41 ) 61 = 81 Q 101 e 121 y 

42 ∗ 62 > 82 R 102 f 122 z 

43 + 63 ? 83 S 103 g 123 { 

44 , 64 @ 84 T 104 h 124 | 

45 − 65 A 85 U 105 i 125 } 

46 . 66 B 86 V 106 j 126 ∼ 

47 / 67 C 87 W 107 k 255 EOF

2 TYPES DE BASE Constantes 78 

→ Il existe trois sortes de constantes : les variables constantes (!), 

les constantes classiques et les constantes énumérées. 

26 

Les variables constantes 

Le mot clé const = spécification du type d’une variable, qui devient 

consultable mais non modifiable. 

2 const double e = 2.71828182845905 ; 

3 const char msg[] = "tableau de caracteres" ; 

4 int strlen (const char s[]) ; 

La vérification que la valeur de telles constantes ne change pas 

est réalisée par le compilateur. Il vérifie qu’aucune ligne de code 

n’essaie explicitement de changer cette valeur. 

(Il peut donc arriver que les constantes soient altérées, par exemple via des 

pointeurs ou des accès hors limite de tableaux ⇒ bugs possibles. . .)


Exemple : 

La compilation avec gcc du morceaux de 

programme suivant produit ce message : 

line 2: error: assignment of read-only 

location 

const.c 

1 void reset (const char s[]) { 

2 s[0] = ’\0’ ; 

3 } 

4 


6 char T[10] ; 

7 

8 reset (T) ; 

9 

10 return 0 ; 

11 } 

27 

Constantes classiques 

Il s’agit des valeurs directement écrites (”en dur”) dans le code 

source, que ce soit des entiers, des réels, mais aussi des chaînes de 

caractères et des caractères. 

3 int i = 12 ; 

4 double r = .5 ; 

5 char c = ’a’ ; 

6 printf ("Hey" " world\n") ; 

12 → [chiffres] + → nombre entier 12 

.5 → [chiffres] ∗ .[chiffres] ∗ → nombre réel 0.5 

’a’ → simples quotes → code ASCII de la lettre a 

"Hey" → doubles quotes → chaîne de caractères


Ces valeurs sont traitées et traduites par le compilateur. Aussi 

écrire x=6.2830; est moins judicieux que d’écrire x=2*3.1415;. 

L’efficacité est la même mais la lisibilité (et donc la maintenabilité) est 

bien meilleure dans le deuxième cas. De même, écrire 

ns=60*60*24; est plus judicieux que ns=86400;. 

Ce traitement s’applique aussi aux chaînes de caractères, qui sont 

automatiquement concaténées par le compilateur lorsqu’elles sont 

séparées juste par quelques espaces. Ceci permet parfois 

d’amméliorer grandement la lisibilité. . . (très longues chaînes) 

28 

Constantes énumérées 

Elles définissent un nouveau type comme étant un ensemble 

d’étiquettes possibles. Les valeurs des étiquettes sont des entiers qui 

se suivent (chaque étiquette prend la valeur de la précédente + 1) en 

partant de 0. (On peut cependant spécifier certaines valeurs).


2 enum logique { FAUX, VRAI } ; /* 0 et 1 */ 

3 enum rien { UN=1, DEUX, TROIS, CINQ=5, SIX } ; 

4 enum direction { LEFT, RIGHT, DOWN, UP } ; 

Le mécanisme de renumérotation est très utile pour spécifier des 

sous-ensembles d’entiers. Le compilateur vérifiera la cohérence des 

valeurs, dans la mesure du possible. 

Exemple : 

Définir une position et coder les 

déplacements possibles. 

RMQ : D’autres valeurs pourraient 

être définies (selon les besoins) : 

LEFT DOWN → x -= 10 ; y -= 10 ; 

RIGHT DOWN → x += 10 ; y -= 10 ; 

LEFT UP → x -= 10 ; y += 10 ; 

RIGHT UP → x += 10 ; y += 10 ; 

7 int x, y ; 

8 enum direction dir ; 

9 

10 /* ... */ 

11 

12 switch (dir) { 

13 case LEFT: 

14 x -= 10 ; 

15 break ; 

16 case RIGHT: 

17 x += 10 ; 

18 break ; 

19 case DOWN: 

20 y -= 10 ; 

21 break ; 

22 case UP: 

23 y += 10 ; 

24 break ; 

25 default: 

26 printf ("Unknown direction\n") ; 

27 }

2 TYPES DE BASE Conversions 82 

29 

Conversions de types 

La conversion d’une variable d’un type T vers un type T’ est 

importante : elle permet d’exprimer une valeur dans le type T vers 

une valeur dans le type T’. 

Exemple : 

récupérer la valeur entière d’une opération en nombre réels, 

opération avec des variables de types différents. 

Par définition, il n’est pas assuré que la valeur dans T’ soit la même 

que celle dans T. (Exemple : l’entier signé -1 vers le type unsigned int. 

Ou encore int i = cos (sqrt ((2))) ;) 

Le programmeur doit expliciter les conversions pour montrer sa prise 

de conscience des riques et erreurs possibles.


Deux façons pour effectuer une conversion : 

1 La bonne : explicitement, via l’opérateur de conversion ”cast”, i.e. 

les parenthèses () encadrant le type destinataire T’. 

2 int i = 4 ; 

3 float r ; 

4 

5 r = (float)i ; 

6 i = (int)r ; 

2 La moins bonne : implicitement, e.g. : un opérateur reçoit des 

opérandes de types différents ⇒ conversion dans un même type. 

5 int i = 5 ; 

6 char c ; 

7 

8 c = ’0’ + i ;


Les conversions implicites sont régies par des règles précises. Si 

aucun opérande n’est du type unsigned, alors : 

Si un des opérandes est long double, l’autre le devient. 

Sinon, si un des opérandes est double, l’autre le devient. 

Sinon, si un des opérandes est float, l’autre le devient. 

Sinon les opérandes de type char et short sont converties en 

int (même si les deux opérandes sont de type char) 

Puis, si un des opérandes est long, l’autre le devient. 

RMQ : Dans du code dont la sûreté est cruciale (applications 

critiques : vies humaines, banques, spatial, . . .), on évitera toute 

conversion. Il est préférable de créer ses propres fonctions de 

conversions traitant les erreurs, qui seront utilisées lorsque cela est 

inévitable.

2 TYPES DE BASE Erreurs 85 

210 

Exemples d’erreurs classiques 

En oubliant qu’il est impossible d’effectuer des opérations sur des 

variables de types différents, on obtient souvent des bugs. . . 

Pourtant, le compilateur ne dit rien, toujours à cause du principe 

”la syntaxe est bonne, le reste concerne le programmeur. . .” 

Ainsi, le compilateur effectue des conversions à l’insu du 

programmeur. . . introduisant ainsi des erreurs. 

5 unsigned short s ; 

6 unsigned long ul ; 

7 float r ; 

8 

9 r = 10e30 ; /* 10eXX signifie 10 puissance XX */ 

10 s = r ; /* on obtient s = 0 !! */ 

11 

12 ul = -1 ; /* le plus grand entier non signe */ 

13 r = ul ; /* on obtient r = 4.294.967.296 

14 alors que ul vaut 4.294.967.295 */

2 TYPES DE BASE Erreurs 86 

Ces erreurs sont rares et peu courantes : elles passent 

inaperçues. 

(Souvent, elles n’apparaissent que lors de phases de tests pointus) 

↩→ Débuggage laborieux pour identifier l’origine de l’erreur. 

Ces erreurs sont bien plus dangereuses quand on manipule des 

pointeurs (adresses mémoire de variables ou de fonctions), car il 

s’agit alors de comment le compilateur joue avec la mémoire. 

Exemple : écrire sur un char les 32 bits d’un int . . . dans ce cas on 

écrit sur de la mémoire qui est utilisée pour d’autres choses (en 

l’occurence 24 bits). 

↩→ Le débuggage de ce genre de ”bugs sévères” peut rapidement 

devenir extrêmement laborieux.

Plan 87 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




3 OPÉRATEURS Affectation d’une variable 88 

Les opérateurs, unaires (un opérande) ou binaires (deux opérandes), 

permettent de manipuler les variables, les nombres et les bits. 

31 

L’opérateur d’affectation 

L’affectation est l’opération qui permet d’attribuer (de donner) une 

valeur à une variable. Cette valeur peut être une constante classique 

(écrite directement dans le code source), la valeur d’une autre 

variable, la valeur résultant de l’évaluation d’une expression ou 

encore le résultat de l’appel d’une fonction. 

Exemple : 

5 int i, j ; 

6 double r, a, b ; 

7 

8 /* ... */ 

9 

10 i = 2 ; 

11 j = (2 * i * i) % 6 - i - 1 ; 

12 r = fabs (sin (a) + exp (b - a)) ;

3 OPÉRATEURS Affectation d’une variable 89 

À chaque variable est associé un espace mémoire (d’une taille 

déterminée par le type → sizeof()). Les affectations permettent 

tout simplement d’aller écrire dans cet espace mémoire. 

Pseudo-code Code C En mémoire 

(1) a : entier int a ; 

(2) b : entier int b ; 

(3) b ← 4 b = 4 ; 

(4) a ← b a = b ; 

(5) a ← a + 2 a = a + 2 ;

3 OPÉRATEURS Échange de deux variables 90 

Pseudo-code Code C En mémoire 

(1) a, b, tmp : entier int a, b, tmp ; 

(2) a ← 1 a = 1 ; 

(3) b ← 6 b = 6 ; 

(4) a ↔ b /* Unknown ? */ 

(5) tmp ← a tmp = a ; 

(6) a ← b a = b ; 

(7) b ← tmp b = tmp ;

3 OPÉRATEURS + − ∗ / % 91 

32 

Les opérateurs arithmétiques 

Les opérateurs arithmétiques sont +, -, *, / et l’opérateur modulo % 

La division entière tronque l’éventuelle partie fractionnaire 

(ex : (int)4/3 donne 1) 

Attention aux erreurs : opérations stables dans ensembles finis 

5 unsigned short a, b ; 

6 

7 /* ... */ 

8 

9 b = a - 1 ; /* quid si a vaut 0 ? */ 

10 a = 256 * 257 ; /* apres l’operation a vaut 256 !! */ 

unsigned int 

∈ [0; 2 16 − 1] = [0; 65537] 

65537 = (256 × 256) − 1 

Attention aux conversions implicites : 

unsigned char c = ’9’ * ’2’ ; /* c vaudra ’"’ */ 

Ici, ’9’ et ’2’ sont convertis en int ; l’opérateur ∗ est alors appliqué ; le 

résultat est converti en unsigned char (soit 50∗57 = 2850, 2850 modulo 

256 = 34, soit ’"’ en ASCII).

3 OPÉRATEURS + − ∗ / % 92 

L’opérateur modulo s’écrit % et ne s’applique qu’aux entiers. Ainsi, 

12%5 donnera 2, alors que 12.2%2 provoque une erreur de 

compilation. 

→ L’opération a % b calcule le reste de la division de la division 

entière de a par b. 

Exemple : 10/3 = 3 et 10%3 = 1 

→ Ainsi, pour savoir si a est divisible par b, 

on peut tester simplement si a%b vaut 0. 

→ Le modulo est également utile pour faire boucler un indice dans un 

intervalle donné : 

3 int incrementer (int i) { 

4 return (i+1) % 10 ; 

5 } 

incrementer(0) renvoie 1 


. . . 


incrementer(9) renvoie 0

3 OPÉRATEURS + − ∗ / % 93 

→ Pour calculer le modulo sur des nombre réels, utiliser les fonctions 

de math.h : 

float fmodf (float x, float y) ; 

double fmod (double x, double y) ; 

long double fmodl (long double x, long double y); 

Les opérateurs + − ∗ / s’appliquent aussi aux réels (float, 

double et long double) 

IMPORTANT : la priorité des opérateurs (table donnée en fin de 

chapitre). 

↩→ Utiliser des parenthèses pour contourner le problème 

Exemple trivial : 

2+5*4 → 22 

(2+5)*4 → 28

3 OPÉRATEURS ++ −− 94 

33 

Incrémentation et décrémentation 

Les deux opérateurs ++ et −−, respectivement incrémente (ajoute 

1) ou décrémente (ôte 1) le contenu d’une variable de type entier. 

Attention : comme tout opérateur, ils retournent une valeur résultat : 

S’il s’agit de l’opérateur de pré-incrémentation (++variable), la 

valeur retournée est la nouvelle valeur incrémentée. 

S’il s’agit de l’opérateur de post-incrémentation (variable++), la 

valeur retournée est l’ancienne valeur avant incrémentation. 

De même pour la pré- et post-décrémentation. 

Exemples : 

RMQ : On utilise ces 

opérateurs plutôt que la forme 

traditionnelle i=i+1; pour deux 

raisons : efficacité et lisibilité 

4 int i, j, k ; 

5 

6 i = 0 ; 

7 j = i++ ; /* j = 0 et i = 1 */ 

8 j = ++i ; /* j = 2 et i = 2 */ 

9 k = j+++i ; /* a voter avis ? k = 4, j = 3, i = 2 */ 

10 

11 /* ... */ 

12 

13 for (i=0 ; i

3 OPÉRATEURS Logiques 95 

34 

Les opérateurs logiques 

Les 4 opérateurs de comparaison sont les suivants : 

> >= <


L’opérateur de négation est simplement l’exclamation : 

Rappel : tables de vérité 

! 

¬V F ¬F V 

ET V F OU V F OUEX V F 

V V F V V V V F V 

F F F F V F F V F 

RMQ : Les opérateurs && et || sont paresseux et s’évaluent de 

gauche à droite, ce qui permet d’écrire : 

5 int x, y, z ; 

6 

7 /* ... */ 

8 

9 while (y!=0 && z>x/y) 

10 y-- ; 

y!=0 sera évalué en premier : 

↩→ Si FAUX, alors pas besoin d’évaluer le 

deuxième opérande de &&, car sera FAUX 

de toute façon (voir table de vérité). 

↩→ Si VRAI, alors z>x/y est évalué.


RMQ : une expression logique vaut 1 si elle est vrai, 0 sinon (pas 

de type booléen). 

Ce fait est crucial. Exemple : 

5 int i, j, x ; 

6 

7 /* ... */ 

8 

9 x = (i == 3) + (j == 2) ; /* x vaut 0 si i!=3 ET j!=2, 

10 1 si i==3 OUEX j==2 

11 2 si i==3 ET j==2 */ 

12 

13 /* boucle infinie qui ne fait rien... */ 

14 while (1) 

15 ; 

16 

17 /* boucle infinie, mais due a une erreur courante */ 

18 for (i=1 ; continuer=1 ; i++) { 

19 ... /* Traitement quelconque */ 

20 if (...) 

21 continuer = 1 ; 

22 else 


24 }

3 OPÉRATEURS Les bits 98 

35 

Traitement des bits 

Il existe 6 opérateurs spécifiques de traitement bit à bit, 5 sont 

binaires et 1 est unaire. Ils sont très puissants, mais souvent 

ignorés. . . 

& ET > décalage à droite 

∧ OU exclusif (OUEX) ∼ complément à 1 (unaire) 

ET bits à bits : c i = a i ET b i 

19 char a, b, c ; 

20 

21 a = 111 ; 

22 b = 119 ; 

23 c = a & b ; 

24 /* c vaut 103 */ 

7 6 5 4 3 2 1 0 

0 1 1 0 1 1 1 1 a 111 

& 0 1 1 1 0 1 1 1 b & 119 

0 1 1 0 0 1 1 1 c 103


OU bits à bits : c i = a i OU b i 

32 char a, b, c ; 

33 

34 a = 111 ; 

35 b = 119 ; 

36 c = a | b ; 

37 /* c vaut 127 */ 

7 6 5 4 3 2 1 0 

0 1 1 0 1 1 1 1 a 111 

| 0 1 1 1 0 1 1 1 b | 119 

0 1 1 1 1 1 1 1 c 127 

OUEX bits à bits : c i = a i OUEX b i 

46 char a, b, c ; 

47 

48 a = 111 ; 

49 b = 119 ; 

50 c = a ˆ b ; 

51 /* c vaut 24 */ 

7 6 5 4 3 2 1 0 

0 1 1 0 1 1 1 1 a 111 

∧ 0 1 1 1 0 1 1 1 b ∧ 119 

0 0 0 1 1 0 0 0 c 24 

Décalage à gauche : b i = a i−1 (b=a


Décalage à droite : b i = a i+1 (b=a>>n; ⇔ b = a/2 n ) 

73 char a, b, c ; 

74 

75 a = 11 ; 

76 b = a >> 1 ; 

77 c = a >> 3 ; 

Complément à 1 b i =!a i 

86 char a, b, c ; 

87 

88 a = 11 ; 

89 b = ˜a ; 

90 c = ˜0 ; 

Exemples : 

7 6 5 4 3 2 1 0 

0 0 0 0 1 0 1 1 a a=11 

0 0 0 0 0 1 0 1 b b=a/2=5 

0 0 0 0 0 0 0 1 c c=a/2 3 =11/8=1 

7 6 5 4 3 2 1 0 

0 0 0 0 1 0 1 1 a a=11 

1 1 1 1 0 1 0 0 b b=∼a=224 

1 1 1 1 1 1 1 1 c c=∼0=255 

19 short i, j, k ; /* 16 bits chacun */ 

20 

21 i = 0xFFFF ; /* met les 16 bits a 1 (0x -> notation hexa) i 1111111111111111 */ 

22 i = i & 255 ; /* met a 0 les 8 bits de poids faible i 0000000011111111 */ 

23 i = i | 0xD000 ; /* met a 1 les 2 bits de poid fort (0x -> hexa) i 1101000011111111 */ 

24 i = i ˆ 017 ; /* inverse les 4 bits faibles (0 -> octal) i 1101000011110000 */ 

25 

26 j = 1 ; /* j 0000000000000001 */ 

27 j = j >= 1 ; /* divise par 2 (j=8) j 0000000000001000 */ 

29 

30 k = 12 ; /* k 0000000000001100 */ 

31 k = 1 + (˜k) ; /* Calcul de l’oppose (k=-12) k 1111111111110100 */


Rappel : Table des nombres sur 8 bits (1 octet) 

Hexa Binaire Octal Décimal Hexa Binaire Octal Décimal 

base 16 base 2 base 8 base 10 base 16 base 2 base 8 base 10 

0 0 0 0 10 10000 20 16 

1 1 1 1 11 10001 21 17 

2 10 2 2 12 10010 22 18 

3 11 3 3 13 10011 23 19 

4 100 4 4 · · · · · · · · · · · · 

5 101 5 5 1F 11111 37 31 

6 110 6 6 20 100000 40 32 

7 111 7 7 · · · · · · · · · · · · 

8 1000 10 8 3F 111111 77 63 

9 1001 11 9 40 1000000 100 64 

A 1010 12 10 · · · · · · · · · · · · 

B 1011 13 11 7F 1111111 177 127 

C 1100 14 12 80 10000000 200 128 

D 1101 15 13 · · · · · · · · · · · · 

E 1110 16 14 FE 11111110 376 254 

F 1111 17 15 FF 11111111 377 255

3 OPÉRATEURS Affectations (suite) 102 

36 

Opérateurs et expressions d’affectations 

L’instruction i=i+2; peut s’écrire de façon plus compacte i+=2; 

L’avantage est que c’est optimisé (liaison avec assembleur). De 

même, pour les opérateurs arithmétiques et de traitements bits à bits, 

il existe les opérateurs d’affectation suivants : 

+= −= ∗= /= %= &= ∧= |= = 

Exemple : 

Fonction de comptage des bits à 1 dans un entier 

3 int compter_bits_version_longue (unsigned x) { 

4 int b ; 

5 

6 for (b=0 ; x!=0 ; x=x>>1) 

7 if ((x & 1) == 1) /* le dernier bit de x est a 1 ? */ 

8 b = b + 1 ; 

9 return b ; 

10 }

3 OPÉRATEURS Affectations (suite) 103 

12 int compter_bits (unsigned x) { 

13 int b ; 

14 

15 for (b=0 ; x!=0 ; x>>=1) 

16 b += x & 1 ; 

17 return b ; 

18 } 

19 

20 int compter_bits_rec (unsigned x) { 

21 return !x ? 0 : (x & 1) + compter_bits_rec (x >> 1) ; 

22 } 

RMQ : Ces opérateurs ont toujours une valeur 

28 int i = 3, j ; 

29 j = (i *= 10) ; /* syntaxiquement bon, lisible ? i=30 et j=30 */ 

37 

Priorité et associativité des opérateurs 

Très importante, car implique ou non l’usage des parenthèses dans 

les expressions.

3 OPÉRATEURS Priorité 104 

Le tableau donne, du haut vers le bas, les opérateurs de priorité plus forte 

vers ceux de priorité plus faible. 

PRIORITÉ OPÉRATEURS ASSOCIATIVITÉ 

Forte () [] -> . → 

! ∼ ++ −− + - ∗ & (cast) sizeof ← 

∗ / % → 

+ − → 

> → 

< = > → 

== ! = → 

& 

→ 

∧ 

→ 

| → 

&& 

→ 

|| → 

? : ← 

= += −= ∗= /= %= ← 

&= ∧= |= = 

Faible , →

Plan 105 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




4 ENTRÉES/SORTIES Entrées/Sorties 106 

Les entrées/sorties (Input/Ouput, I/O) sont les échanges 

d’informations entre un processus et les ressources système 

(matérielles et logicielles) 

Les entrées sont les données envoyées par une ressource à 

destination d’un processus 

Les sorties sont les données envoyées par un processus à destination 

d’une ressource 

Processus = un programme en cours d’exécution (définition approximative)

4 ENTRÉES/SORTIES Entrées/Sorties 107 

Une entrée est un flux de données comme : 

La saisie au clavier 

Les mouvements de la souris 

La lecture d’un fichier sur le disque dur 

La réception d’un message sur le réseau 

La réception d’un signal d’un port d’une carte électronique 

. . . 

Une sortie est un flux de données comme : 

L’affichage à l’écran 

L’écriture d’un fichier sur le disque dur 

L’émission d’un message sur le réseau 

L’émission d’un signal sur un port d’une carte électronique 

L’écriture de données sur l’imprimante 

. . .

4 ENTRÉES/SORTIES Notion de processus 108

4 ENTRÉES/SORTIES Notion de processus 109

4 ENTRÉES/SORTIES Écriture à l’écran 111 

Le prototype de la fonction printf() est : 

int printf (const char *format, ...) ; 

RMQ : printf() retourne le nombre de caractères écrits (ou une 

valeur négative le cas échéant, par exemple si une erreur de sortie 

s’est produite.) 

RMQ : ”. . .” ⇒ nombre variable d’arguments (cf. stdarg.h). 

42 

Écriture de valeurs 

Pour produire l’affichage du contenu d’une variable : 

1 Marquer la position où la valeur doit apparaître avec un 

caractère % 

2 Puis indiquer par une lettre le format de conversion qui devra 

être utilisé (%d, %f, %s, etc.) 

3 Enfin, ajouter le nom de la variable aux arguments de printf()


Exemple 1 : 

5 int i = 5 ; 

6 float r = sqrt (2) ; 

7 

8 printf ("i vaut %d et r vaut %f\n", i, r) ; 

Produit l’affichage suivant : 

RMQ : Dans le cas de plusieurs variables, ces dernières sont 

données en argument de printf() dans leur ordre d’apparition 

Exemple 2 : 

4 int i = 4053 ; 

5 printf ("i vaut %X\n", i) ;


Exemple 3 : 

5 int i = 5 ; 

6 

7 printf ("Le carre de %d vaut %d\n", i, i*i) ; 

8 printf ("La racine de %d vaut %lf\n", i, sqrt(i)) ; 

Produit l’affichage suivant : 

RMQ : L’affichage de valeurs dans printf() n’est pas limité aux 

variables. En effet, ce peut être le résultat de l’évaluation d’une 

expression ou encore la valeur renvoyée par l’appel d’une fonction. 

RMQ : Rappel : ’\n’ est le caractère de ”retour à la ligne”.


43 

Nombre minimum de caractères produits 

→ Certains formats de conversion sont paramétrables. 

Par exemple, il est possible de spécifier le nombre minimum de 

caractères à imprimer en le spécifiant entre le % et le caractère de 

formatage : 

4 printf ("%5d\n", 45) ; 

5 printf ("%5d\n", 129) ; 

6 printf ("%5d\n", 1032) ; 

7 printf ("%5d\n", 100034) ; 

45 

129 

1032 

100034 

RMQ : Ne pas oublier que c’est le nombre minimum de caractères 

à imprimer qui est ainsi contrôlé. Si le nombre comporte plus de 

chiffres, alors il y aura dépassement (p.ex. ligne 7).


→ Concernant les nombres réels, le nombre de minimum de 

caractères à imprimer peut également être spécifié, ainsi que le 

nombre de décimales à imprimer après la virgule. 

4 printf ("%f\n", .0) ; 

5 printf ("%f\n", 10.08) ; 

6 printf ("%.1f\n", 100.08) ; 

7 printf ("%10.3f\n", 5.454) ; 

8 printf ("%10.3f\n", 5.454e4) ; 

9 printf ("%10.3f\n", 5.454e5) ; 

10 printf ("%10.3f\n", 5.454e6) ; 

0.000000 

10.080000 

100.1 

5.454 

54540.000 

545400.000 

5454000.000 

↩→ La valeur indiquée APRES le point est le nombre imposé de 

décimales à imprimer. La valeur indiquée AVANT le point est le 

nombre minimum de caractères à imprimer au total (y compris les 

décimales après la virgule ET la virgule elle-même). 

RMQ : Si rien n’est spécifié le format par défaut est %.6f (voir 

lignes 4 et 5). L’arrondi est réalisé automatiquement (voir ligne 6).


44 

Table des formats possibles pour printf() 

Caractère Argument Impression 

d, i int décimal 

o int octal 

x, X int hexadécimal 

u unsigned int entier non signé 

s char * 

chaîne de caractères (doit se 

terminer par ’\0’) 

c char caractère 

f double [-]m.dddddd 

e, E double [-]m.ddddd{e|E}±xx (⇔ ×10 xx ) 

g, G double 

utilise e ou E si xx < −4 ou > 6, 

f sinon 

p void * pointeur 

% aucun imprime un %


→ Seuls les types de base sont acceptés par printf(). Il est 

impossible d’afficher une variable d’un type nouveau (créé par le 

programmeur). 

RMQ : Les char servent aussi bien, à représenter de petits 

nombres entiers [−128; +127], qu’à représenter des caractères. 

Cette situation est normal, du fait que les caractères sont 

effectivement codés par leur nombre ascii.


Exemple du cas char : 

4 char A = 121 ; 

5 char B = ’z’ ; 

6 

7 printf ("A = %d\n", A) ; 

8 printf ("A = %c\n", A) ; 

9 printf ("B = %c\n", B) ; 

10 printf ("B = %d\n", B) ; 

RMQ : Un modificateur de longueur doit être ajouté pour les types 

”longs” : un l pour les entiers et un L pour les réels. Exemples 

d’utilisation (non exhaustif) : 

Type 

long int 

long long int 

unsigned long int 

unsigned long long int 

long double 

Format 

ld, li 

lld, lli 

lu, lu 

llu, llu 

Lf, Le, Lg

4 ENTRÉES/SORTIES La sortie d’erreur 119 

45 

Un flux de sortie distinct pour les erreurs 

En fait, par défaut, un deuxième flux de sortie est toujours créé pour 

chaque processus. 

→ Ce ”canal” est destiné à recevoir les messages d’erreur, ou 

d’avertissement, pour les distinguer des messages dits ”normaux” 

→ Par défaut, le flux d’erreur est dirigé vers la console 

→ Mais des mécanismes existent (nous en verrons un juste après) pour 

modifier la destination de ces flux et pouvoir les dissocier

4 ENTRÉES/SORTIES La sortie d’erreur 120 

Pour ce faire, la fonction fprintf() permet de choisir le flux 

d’écriture. Son prototype est : 

int fprintf (FILE *stream, const char *format, ...) ; 

→ Ainsi, un appel fprintf(stderr, ...); produira une écriture 

sur la sortie d’erreur (dont le descripteur est stderr) 

Exemple : 

addition.c 


8 if (argc != 3) { 



11 } 

RMQ : Noter que ces deux appels sont équivalents : 

printf(...); 

fprintf(stdout, ...);

4 ENTRÉES/SORTIES Redirection 121 

46 

Les redirections 

Au moment de l’appel d’un programme, la destination habituelle des 

sorties standards (stdout et stderr) peut être changée 

1 Récupérer la sortie standard en la redirigeant dans un fichier 

Exemple : monprogramme.exe > sortie.txt

4 ENTRÉES/SORTIES Redirection 122 

2 Récupérer la sortie d’erreur en la redirigeant dans un fichier 

Exemple : monprogramme.exe 2> sortie.txt 

3 Ignorer une des sorties en la redirigeant vers NUL 

Exemple : monprogramme.exe > sortie.txt 2> NUL

4 ENTRÉES/SORTIES Lecture au clavier 123 

La fonction scanf() lit des caractères en provenance de l’entrée 

standard (stdin). Sauf cas particuliers, l’entrée standard est le 

clavier de l’ordinateur. 

47 

Comportement (asynchrone) de scanf() 

Lorsque les touches du clavier sont frappées, le Système 

d’Exploitation (OS) stocke les caractères émis dans une zone 

mémoire tampon (buffer). Le rôle de la fonction scanf() est d’aller 

”manger” les caractères présents dans ce buffer.


Les appels à la fonction scanf() sont bloquants : 

si le buffer est vide, l’exécution du programme est mise en attente 

jusqu’à ce qu’il y ait des caractères à ”manger”. 

l’exécution du programme est réactivée lors d’une frappe sur la 

touche Entrée (Enter), 

(sinon) si le buffer n’est pas vide, alors la fonction scanf() 

”mange” les caractères autant que faire se peut. 

scanf() interprète les suites de caractères lues pour former 

des valeurs qui sont ensuite affectées à des variables. 

48 

Utilisation de scanf() 

Le prototype de la fonction scanf() est : 

int scanf (const char *format, ...) ; 

→ Le premier paramètre format est une chaîne de caractères qui 

informe scanf() sur le format de conversion à utiliser pour 

interpréter le flux de caractères ACSII en provenance du clavier


→ Genre de conversions effectuées par scanf() : 

ASCII → nombre entier : scanf("%d", ...); 

ASCII → nombre réel : scanf("%f", ...); 

ASCII → ASCII : scanf("%s", ...); ou scanf("%c", ...); 

→ Les autres paramètres sont les adresses des emplacements 

mémoire où scanf() devra aller écrire les valeurs lues : 

scanf("%d", &n); 

scanf("%f", &x); 

scanf("%s", mot); 

scanf("%c", &lettre); 

(avec int n;) 

(avec float x;) 

(avec char mot[MAX];) 

(avec char lettre;) 

RMQ : Précéder le nom d’une variable par l’opérateur & permet 

d’obtenir son adresse mémoire. 

↩→ IMPORTANT : ne pas le faire pour les chaînes de caractères, 

car en fait c’est déjà une adresse mémoire (vers un tableau) !


→ la valeur retournée par scanf() est le nombre d’éléments 

correctement mis en correspondance et assignés. Ce nombre peut 

être plus petit que le nombre d’éléments attendus, voire être nul. 

Exemple : 

Récupérer un nombre entier entré au clavier puis afficher sa valeur 

Cas nominal : 

lecture.c 

1 #include 

2 


4 int i ; 

5 

6 printf ("Donnez un entier : ") ; 

7 if (scanf ("%d", &i) == 1) 

8 printf ("lu %d\n", i) ; 

9 else 

10 printf ("erreur de lecture\n") ; 

11 

12 return 0 ; 

13 } 

Cas non nominal :


49 

Table des formats possibles pour scanf() 

Caractère Entrée Argument 

d, i un entier en décimal int * 

o un entier en octal int * 

x un entier en hexadécimal int * 

u un entier non signé unsigned int * 

s 

une chaîne de caractères 

(lira jusqu’au au premier char * 

espace ou ’\n’ rencontré) 

c 

un caractère (les espaces et 

les ’\n’ seront ignorés) 

char * 

hhd un entier ∈ [−128; +127] char * 

e, f, g un réel float * 

le, lf, lg un réel double * 

% attend un %


Résultats : 

(type argument) : 

. -> lu 

RMQ : Pour pouvoir ne ”manger” qu’un seul caractère à la fois 

avec %c, comme dans l’exemple ci-dessus, un caractère résiduel ’\n’ 

présent dans le buffer doit éventuellement être ignoré. Pour ce faire, 

une astuce consiste à placer un espace avant le %c dans le format : 

scanf (" %c", &var) ;


→ Modificateurs pour les types ”courts” (h) et ”longs” (l, L) : 

Caractère Entrée Argument 

hhd entier ∈ [−128; 127] char * 

hd entier ∈ [−32768; 32767] short int * 

ld entier long int * 

lld 

entier ∈ [−2 63 ; 2 63 − 1] 

(2 63 = 9, 223372 × 10 18 ) 

long long int * 

hhu entier ∈ [0; 255] unsigned char * 

hu entier ∈ [0; 65535] unsigned short int * 

lu entier long unsigned int * 

llu 

entier ∈ [0; 2 64 − 1] 

= [0; 1, 84467441 × 10 19 ] 

long long unsigned * 

Le, Lf, Lg réel (plus grand = ) long double * 

RMQ : Pour %ld et %lu l’intervalle dépend de l’architecture 

machine (en général 4 octets, mais se référer à sizeof()).

4 ENTRÉES/SORTIES Accès fichiers 130 

Pour lire et écrire dans des fichiers stockés sur le disque dur, il faut 

demander au Système d’Exploitation d’ouvrir d’autres descripteurs 

→ Fichier de configuration 

→ Fichier de sauvegarde 

→ Scores, Traitements, CSV, . . .


410 

Demander l’ouverture d’un descripteur de fichier 

Afin d’établir un ”canal d’accès” vers un fichier sur le disque dur, 

il faut créer un nouveau descripteur à cet effet 

Ce descripteur pourra ensuite être utilisé pour accéder à la 

ressource (le fichier) en lecture ou en écriture 

De même que pour les entrées standards, un tampon (buffer) 

temporise les accès (→ Noyau du SE) 

La fonction fopen() permet d’ouvrir des descripteurs de fichiers : 

FILE *fopen (char *path, char *mode) ; 

path : nom du fichier (chemin d’accès absolu ou relatif) 

mode : genre du descripteur à créer, d’entrée ou de sortie 

La valeur renvoyée est l’adresse du nouveau descripteur (une structure 

de type FILE)


→ Le paramètre path est une chaîne de caractères décrivant le nom 

du fichier à ouvrir (précédé du chemin d’accès sur le disque) 

Exemple : 

Si répertoire de travail = 

"M:\Example\debug\" 

Chemins relatifs : 

"config.txt" 

"..\data\save.txt" 

"users\dennis.txt" 

Chemins absolus : 

"M:\Mesures\valeurs.csv" 

"M:\Example\data\save.txt" 

RMQ : Le répertoire de travail sera le répertoire depuis lequel 

l’exécution du programme sera lancée 

RMQ : Le caractère de séparation est / sous Unix, Linux et Mac


→ Le paramètre mode est une chaîne de caractères parmi : 

"r" = read : accès en lecture simple 

"w" = write : accès en écriture (écrasement si le fichier existe, création 

le cas échéant) 

"a" = append : accès en écriture (positionne le ”curseur” à la fin si le 

fichier existe, création le cas échéant) 

Un appel à la fonction fopen() peut échouer pour raisons diverses, 

parmi lesquelles : 

Tentative d’accès en lecture à un fichier qui n’existe pas 

Tentative d’accès en écriture à un fichier qui est déjà ouvert 

Les droits d’accès au fichier sont restreints 

↩→ En cas d’échec, la valeur renvoyée par fopen() vaut alors NULL 

RMQ : NULL est une valeur particulière définie comme 

(void *)0 et déclarée dans stddef.h qui signifie ”pointeur nul”


RMQ : La fonction fopen() produit un appel système et en cas d’échec 

il est possible de connaître la raison de cet échec en consultant la variable 

d’erreur errno (qui a été positionnée par le système) via un appel à 

perror() 

IMPORTANT : une fois que les traitements sur le fichier sont terminés 

et qu’on en n’a plus besoin, il faut toujours penser à appeler la 

fonction fclose() : 

int fclose (FILE *fp) ; 

Aussi, lorsqu’un fichier est ouvert en écriture, le fermer (après 

utilisation) est important car cela provoquera la synchronisation du 

buffer d’écriture avec le disque dur


Exemple d’utilisation : 

5 FILE *fp ; 

6 

7 fp = fopen ("scores.txt", "w") ; 

8 

9 if (fp == NULL) { 

10 perror("Failed to open scores.txt in write mode"); 

11 exit (-1) ; 

12 } 

13 

14 /************************* 

15 * ECRIRE dans le fichier 

16 *************************/ 

17 

18 fclose (fp) ;


411 

Écrire dans un fichier avec fprintf() 

Comme précédemment vu, la fonction fprintf() permet d’écrire 

des caractères ASCII sur le flux de sortie qui lui est spécifiée 

→ Pour écrire dans un fichier, il suffit donc de lui fournir le descripteur 

du fichier dans lequel on souhaite écrire 

↩→ un descripteur ouvert en écriture obtenu par appel à fopen() 

Rappel : 

int fprintf (FILE *stream, const char *format, ...) ; 

RMQ : Le caractère de fin de ligne diffère selon le Système 

d’Exploitation utilisé 

Pour marquer une fin de ligne dans un fichier : sous Windows : \r\n 

sous MacOS : \n\r 

sous Unix/Linux : \n


Exemple : 

ecrire-table-carre.c 

1 #include 

2 #include 

3 


5 int n ; 

6 FILE *outbuf ; 

7 

8 /* Ouverture d’un descripteur en mode ECRITURE */ 

9 if ((outbuf = fopen ("table.txt", "w")) == NULL) { 

10 perror("Failed to open table.txt in write mode"); 

11 exit (-1) ; 

12 } 

13 

14 /* Ecriture dans le fichier (via le descripteur...) */ 

15 fprintf (outbuf, "TABLE DES CARRES\r\n") ; 

16 

17 for (n=0 ; n


412 

Lire dans un fichier avec fscanf() 

La fonction fscanf() permet de lire des caractères ASCII provenant 

du flux d’entrée qui lui est spécifiée 

→ Pour lire dans un fichier, il suffit donc de lui fournir le descripteur 

du fichier dans lequel on souhaite lire 

↩→ un descripteur ouvert en lecture obtenu par appel à fopen() 

int fscanf (FILE *stream, const char *format, ...) ; 

RMQ : De même que scanf(), cette fonction devra prendre pour 

paramètre des adresses de variables


Exemple : 

lire-annuaire.c 

1 #include 

2 #include 

3 


5 char name[512] ; 

6 int year, lu ; 

7 FILE *inbuf ; 

8 

9 /* Ouverture d’un descripteur en mode LECTURE */ 

10 if ((inbuf = fopen ("annuaire.txt", "r")) == NULL) { 

11 perror("Failed to open annuaire.txt in read mode"); 

12 exit (-1) ; 

13 } 

14 

15 /* Lecture du fichier ligne par ligne */ 

16 while (!feof (inbuf)) { 

17 lu = fscanf (inbuf, "%s %d", name, &year) ; 

18 

19 if (lu == 2) 

20 printf ("Nom=%s \t Date=%u\n", name, year) ; 

21 } 

22 

23 /* Fermeture du descripteur de fichier */ 

24 fclose (inbuf) ; 

25 

26 return 0 ; 

27 } 

annuaire.txt 

1 Ritchie 1941 

2 Kernighan 1942 

3 Thompson 1943 

4 Stallman 1953 

5 Gates 1955 

6 Jobs 1955 

7 Torvalds 1969 

8 _


413 

Accès fichiers caractère par caractère 

Lecture d’un caractère 

Écriture d’un caractère 

int fgetc (FILE *stream) ; 

int fputc (int c, FILE *stream) ; 

Ces deux fonctions retournent le code ASCII du caractère lu/écrit 

(unsigned char vers int), ou la valeur EOF en cas d’erreur (End 

Of File, vaut -1) 

Exemple : copie caractère par caractère 

↩→ voir le ”Huitième programme” au début du cours (copier.c)


Exemple de lecture caractère par caractère : 

compterT.c 

1 #include 

2 #include 

3 


5 FILE *fp ; 

6 char c ; 

7 int cpt = 0 ; 

8 

9 /* Ouverture du fichier en lecture */ 

10 if ((fp = fopen ("annuaire.txt", "r")) == NULL) { 

11 perror ("Failed to open annuaire.txt in read mode"); 

12 exit (-1) ; 

13 } 

14 

15 /* Lecture caractere par caractere */ 

16 while ((c = fgetc (fp)) != EOF) 

17 if (c == ’T’) 

18 cpt++ ; 

19 

20 /* Fermeture du fichier */ 

21 fclose (fp) ; 

22 

23 printf ("Nombre de T = %d\n", cpt) ; 

24 

25 return 0 ; 

26 } 

annuaire.txt 

1 Ritchie 1941 

2 Kernighan 1942 

3 Thompson 1943 

4 Stallman 1953 

5 Gates 1955 

6 Jobs 1955 

7 Torvalds 1969 

8 _ 

Ce programme compte les 

occurrences de la lettre T 

dans le fichier 

annuaire.txt

Plan 143 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




5 CONTRÔLE & BOUCLES Introduction 144 

En programmation impérative, les instructions 

sont exécutées pas à pas, les unes après les 

autres, dans l’ordre indiqué par le programmeur 

6 scanf ("%d", &a) ; 

7 scanf ("%d", &b) ; 

8 c = a + b ; 

Une structure de contrôle est une commande qui permet de 

jouer sur l’ordre dans lequel les instructions seront exécutées 

Certaines, appelées conditionnelles, permettent de 

décider l’exécution, ou non, des (blocs d’) instructions 

ou encore, de choisir les (blocs d’) instructions à 

exécuter 

10 if (a > b) 

11 max = a ; 

12 else 

13 max = b ; 

D’autres sont itératives (appelées boucles) et permettent de 

répéter plusieurs fois les mêmes (blocs d’) instructions 

15 for (i=1 ; i

5 CONTRÔLE & BOUCLES Les conditionnelles 145 

Il existe deux structures de contrôle de prise de décision 

conditionnelle : 

if (...) ... [ else ...] 

switch (...) case ... default ... 

et un opérateur : 

(...) ? ...: ... 

51 

La structure conditionnelle classique if 

if (expression) 

instruction ; 

L’instruction sera exécutée si et seulement 

si l’expression booléenne vaut VRAI (valeur 

entière != 0). Ainsi, si l’expression vaut FAUX 

(valeur entière == 0), l’instruction ne sera pas 

exécutée


if (expression) { 

instruction1 ; 

instruction2 ; 

... 

instructionN ; 

} 

if (expression) { 

/* blocA */ 

} 

else { 

/* blocB */ 

} 

Délimiter un bloc d’instructions entre des 

accolades { ... } permet de soumettre 

plusieurs instructions à la conditionnelle 

(Valable également dans le cas d’une 

seule instruction) 

L’ajout du else permet de définir un 

comportement dans le cas où la 

condition n’est pas vérifiée. Ainsi, si la 

condition vaut VRAI alors le bloc A sera 

exécuté. Sinon (cas où la condition vaut 

FAUX) c’est le bloc B qui sera exécuté. 

RMQ : La condition peut-être une variable entière, une expression 

bouléenne, un appel de fonction, . . .


Trois exemples de if simples : 

3 int x ; 

4 double y ; 

5 

6 /* ... */ 

7 

8 if (x != 0) 

9 y = 1 / x ; 

3 int x, max ; 

4 

5 /* ... */ 

6 

7 if (x > max) { 

8 max = x ; 

9 } 

3 int x ; 

4 

5 /* ... */ 

6 

7 if (x < 0) { 

8 x = -x ; 

9 } 

Deux exemples de if else : 

5 if (a > b) { 

6 max = a ; 

7 min = b ; 

8 } 

9 else { 

10 max = b ; 

11 min = a ; 

12 } 

7 int year, ndays ; 

8 

9 /* ... */ 

10 

11 if (is_bissextile (year)) 

12 ndays = 366 ; 

13 else 

14 ndays = 365 ;


Encore deux exemples divers : 

4 int i, N=10 ; 

5 int a[N], val ; 

6 

7 /* ... */ 

8 

9 if (i >= 0 && i < N) 

10 a[i] = val ; 

11 else 

12 printf ("index out of range\n"); 

4 char found = 0 ; 

5 

6 

7 /* ... */ 

8 

9 

10 if (!found) { 

11 printf ("search failed\n") ; 

12 } 

RMQ : Puisque FAUX équivaut à zéro, on peut raccourcir certaines 

écritures. Ainsi, cette écriture : 

if (c != 0) ... 

(lisible) 

peut être efficacement remplacée par : 

if (c) ... 

(optimisé) 

↩→ Sera, de toute façon, optimisé par le compilateur


→ Imbrication de plusieurs if : 

confusion du else. 

Exemple d’erreur : 

Le contrôle par else n’est pas associée 

par le compilateur au if (n > 0), 

mais au if (a[i] > 0). 

La bonne version est alors : 

Moralité : toujours mettre entre 

accolades les instructions, mêmes 

atomiques, afin d’éviter les confusions 

en cas de else 

Recherche d’1 valeur strict. positive 

dans un tableau a de n éléments. 

9 if (n > 0) 

10 for (i=0 ; i 0) { 

12 printf ("Trouve!!\n") ; 

13 pos = i ; 

14 } 

15 else /* Mauvais niveau */ 

16 printf ("Tableau vide\n") ; 

9 if (n > 0) { 

10 for (i=0 ; i 0) { 

12 printf ("Trouve!!\n") ; 

13 pos = i ; 

14 } 

15 } 

16 else { /* Bon niveau */ 

17 printf ("Tableau vide\n") ; 

18 }


RMQ : Ne pas confondre les opérateurs == et = 

if (c == 0) ... /* ok */ 

if (c = 0) ... /* argh!! */ 

La dernière condition est syntaxiquement correcte, elle pourrait 

même être fait exprès, mais reste absolument proscrite pour éviter 

les ambiguïté de relecture ! 

Par contre, les programmeurs utilisent ce mécanisme dans 

certains cas (affection suivie d’une comparaison), pour compacter 

l’écriture et optimiser l’exécution : 

5 char filename[256] ; 

6 FILE *fp ; 

7 

8 /* ... */ 

9 

10 if ((fp = fopen (filename, "r")) == NULL) { 

11 perror("Failed to open in read mode"); 

12 exit (-1) ; 

13 } 

5 char filename[256] ; 

6 FILE *fp ; 

7 

8 /* ... */ 

9 

10 fp = fopen (filename, "r") ; 

11 

12 if (fp == NULL) { 

13 perror("Failed to open in read mode"); 

14 exit (-1) ; 

15 }


52 

Le contrôle par else if 

Écrire des conditions avec un choix entre plusieurs possibilités. 

if (expressionA) { 

/* blocA */ 

} 

else if (expressionB) { 

/* blocB */ 

} 

else if (expressionC) { 

/* blocC */ 

} 

else { 

/* blocZ */ 

} 

Si l’expression A est vrai alors 

(uniquement) le bloc A est 

exécuté. Sinon, si l’expression B 

est vrai alors c’est le bloc B 

(uniquement) qui est exécuté. Et 

ainsi de suite pour tous les 

else if. Si aucune des 

conditions n’a été vérifiée (et donc 

qu’aucun des blocs précédents 

n’a été exécuté), alors le bloc Z 

est exécuté (uniquement).


Deux exemples : 

6 if (x > y) { 

7 printf ("x est superieur a y\n") ; 

8 } 

9 else if (x < y) { 

10 printf ("x est inferieur a y\n") ; 

11 } 

12 else { 

13 printf ("x et y sont egaux\n") ; 

14 } 

6 if (i < 0) { 

7 i = 0 ; 

8 } 

9 else if (i > 10) { 

10 i = 10 ; 

11 } 

RMQ : Les conditions sont évaluées dans l’ordre croissant et 

l’évaluation des expressions s’arrête à la première condition 

rencontrée qui est vérifiée 

RMQ : Il est possible d’enchaîner autant de else if que 

nécessaire 

RMQ : Le else final est facultatif


Exemple : 

Recherche dichotomique d’une valeur x dans un tableau a trié par ordre 

croissant de taille N 

7 int dicho (int x, int a[], int N) { 

8 int debut, fin, milieu ; 

9 fin = N-1 ; 

10 debut = 0 ; 

11 while (debut a[milieu]) 

16 debut = milieu + 1 ; 

17 else /* trouve ! */ 

18 return milieu ; 

19 } 

20 return -1 ; /* pas trouve */ 

21 }


Attention, ces deux écritures ne sont pas équivalentes : 


/* blocA */ 

} 

else if (expressionB) { 

/* blocB */ 

} 

else if (expressionC) { 

/* blocC */ 

} 


/* blocA */ 

} 

if (expressionB) { 

/* blocB */ 

} 

if (expressionC) { 

/* blocC */ 

} 

Par exemple, si les 3 expressions A, B et C sont vérifiées : 

Seulement le bloc A 

sera exécuté 

(exclusivement) 

Les 3 blocs A, B et C 

seront exécutés

5 CONTRÔLE & BOUCLES Opérateur conditionnelle 155 

53 L’opérateur de conditionnelle ? : 

Il est parfois pratique de remplacer l’instruction conditionnelle : 

if (expression) instruction1 ; else instruction2 ; 

par : 

expression ? instruction1 : instruction2 ; 

Avantages : 

efficacité 

lisibilité 

retourne une valeur ! (car opérateurs . . .) 

Exemple : 

4 int a, b, max ; 

5 

6 /* ... */ 

7 

8 max = (a > b) ? a : b ; 

4 int a, b, max ; 

5 

6 /* ... */ 

7 

8 if (a > b) 

9 max = a ; 

10 else 

11 max = b ;

5 CONTRÔLE & BOUCLES Opérateur conditionnelle 156 

Autres exemples : 

8 char reussie ; 

9 

10 /* ... */ 

11 

12 printf ("La reponse est %s\n", (reussie) ? "vrai" : "fausse") ; 

Attention : cet opérateur ne peut pas toujours se substituer à la 

structure de contrôle if classique 

↩→ Lorsque les instructions à exécuter sont complexes (blocs. . .) 

↩→ Dans les cas où la valeur de retour n’est pas utilisée

5 CONTRÔLE & BOUCLES Choix multiples 157 

54 

La structure de contrôle switch 

Cette structure de contrôle permet une prise de décision à choix 

multiples, effectuée par comparaisons successives d’une expression 

avec des expressions constantes entières. 

La syntaxe est la suivante : 

switch (expression) { 

case expression-constante1 : instructionS 

[ break ; ] 

case expression-constante2 : instructionS 

[ break ; ] 

... 

default: instructionS 

}


Principe de fonctionnement : 

1 La valeur entière de l’expression (du switch) sera comparée 

avec celles des expressions constantes (des case) 

2 Les instructions seront exécutées à partir de la première égalité 

rencontrée 

3 Alors, TOUT le code qui suit sera exécuté, sans tenir compte des 

autres case, jusqu’à rencontrer une instruction break 

Exemple : 

le code suivant, qui devrait associer 

un nombre à un jour de la semaine, 

est erroné 

Lorsque jour vaut 4 l’affichage est : 

4 int jour ; 

5 

6 /* ... */ 

7 

8 jour = 4 ; 

9 

10 switch (jour) { 

11 case 1 : printf ("lundi\n") ; 

12 case 2 : printf ("mardi\n") ; 

13 case 3 : printf ("mercredi\n") ; 

14 case 4 : printf ("jeudi\n") ; 

15 case 5 : printf ("vendredi\n") ; 

16 case 6 : printf ("samedi\n") ; 

17 case 7 : printf ("dimanche\n") ; 

18 default : printf ("unknown value\n") ; 

19 }


↩→ Correction de l’exemple précédent : 

⇒ Lorsqu’il est nécessaire d’interrompre 

l’enchaînement des instructions, il faut alors 

utiliser l’instruction break 



4 int jour ; 

5 

6 /* ... */ 

7 

8 switch (jour) { 

9 case 1 : 

10 printf ("lundi\n") ; 

11 break ; 

12 case 2 : 

13 printf ("mardi\n") ; 

14 break ; 

15 case 3 : 

16 printf ("mercredi\n") ; 

17 break ; 

18 case 4 : 

19 printf ("jeudi\n") ; 

20 break ; 

21 case 5 : 

22 printf ("vendredi\n") ; 

23 break ; 

24 case 6 : 

25 printf ("samedi\n") ; 

26 break ; 

27 case 7 : 

28 printf ("dimanche\n") ; 

29 break ; 

30 default : 

31 printf ("unknown value\n") ; 

32 }


RMQ : La ligne contenant le cas par défaut (default : ...) est 

optionnelle 

↩→ Elle est exécutée lorsqu’aucun des cas listés (case) ne 

correspond à la valeur de l’expression de sélection (switch) 

↩→ De façon générale, le cas par défaut doit toujours être traité, ne 

serait-ce que pour afficher une erreur lorsque, contre toute attente, il 

a été atteint lors d’une exécution 

Exemple : 

Une fonction qui calcule 

le nombre de jours dans 

un mois 

3 int days_count (int month, char bissextile) { 

4 int res = -1 ; 

5 switch (month) { 

6 case 1: case 3: case 5: case 7: case 8: case 10: case 12: 

7 res = 31 ; break ; 

8 case 4: case 6: case 9: case 11: 

9 res = 30 ; break ; 

10 case 2: 

11 res = (bissextile) ? 29 : 28 ; break; 

12 default: 

13 fprintf(stderr, "Unknow value\n") ; 

14 } 

15 return res ; 

16 }

5 CONTRÔLE & BOUCLES Boucles 161 

Les boucles permettent d’exécuter un bloc d’instructions données 

tant qu’une condition donnée n’est pas remplie 

Il existe deux genres de boucles : 

→ avec exécution d’instruction(s) AVANT le test de continuation 

(while et for) 

→ avec exécution d’instruction(s) APRÈS le test de continuation 

(do...while) 

Applications : 

Demander à l’utilisateur un nombre compris dans un certain intervalle 

Demander N nombres à l’utilisateur 

Faire varier un indice pour parcourir les cases d’un tableau de taille N 

Faire varier deux indices pour parcourir une matrice de taille N×M 

Lire un fichier ligne par ligne / caractère par caractère 

Recommencer un programme plusieurs fois 

· · ·

5 CONTRÔLE & BOUCLES while 162 

55 

La boucle while 

Syntaxe : 

while (expression) 

instruction ; 

while (expression) { 

/* bloc */ 

} 

Tant que l’expression est vrai (i.e. non nulle), alors l’instruction est 

exécutée (éventuellement un bloc d’instructions) 

Exemple : 

Ce programme 

demande des 

nombres jusqu’à ce 

que leur somme 

atteigne 100 

somme-max100.c 

1 #include 

2 


4 int n, sum=0 ; 

5 printf ("Somme limite = 100 !!!\n") ; 

6 while (sum < 100) { 

7 printf ("Donnez un nombre : ") ; 

8 scanf ("%d", &n) ; 

9 sum += n ; 

10 } 

11 printf ("La somme limite a ete atteinte ou depassee\n") ; 

12 return 0 ; 

13 }

5 CONTRÔLE & BOUCLES while 163 

Autre exemple : 

somme-positifs.c 

1 #include 

2 


4 char continuer=1 ; 

5 int n, sum=0 ; 

6 

7 while (continuer) { 


9 scanf ("%d", &n) ; 

10 if (n == 0) 


12 else if (n > 0) 

13 sum += n ; 

14 } 

15 printf ("La somme des positifs est %d\n", sum) ; 

16 return 0 ; 

17 } 

Ce programme calcule la 

somme des nombres positifs 

jusqu’à ce qu’un nombre nul soit 

entré

5 CONTRÔLE & BOUCLES for 164 

56 

La boucle for 

Syntaxe : 

for (initialisation ; expression ; action) 

instruction ; 

for (initialisation ; expression ; action) { 

/* bloc */ 

} 

⇒ La boucle for équivaut à : initialisation ; 

while (expression) { 

/* bloc */ 

action ; 

}


Exemple : 

Ces deux boucles 

sont équivalentes 

4 int i ; 

5 

6 for (i=0 ; i


Parcours de tableaux 

4 int tab[5], i ; 

5 

6 /* ... */ 

7 

8 printf ("Tableau = (") ; 

9 for (i=0 ; i


Longueur d’une chaîne de caractères 

→ version for 

1 #include 

2 #include 

3 



6 int i ; 

7 

8 strcpy (nom, "ESTIA") ; 

9 

10 for (i=0 ; nom[i] != ’\0’ ; i++) 

11 ; 

12 

13 printf ("Longeur : %d\n", i) ; 

14 return 0 ; 

15 } 

→ version while 

1 #include 

2 #include 

3 



6 int i ; 

7 

8 strcpy (nom, "ESTIA") ; 

9 

10 i = 0 ; 

11 while (nom[i] != ’\0’) 

12 i++ ; 

13 

14 printf ("Longeur : %d\n", i) ; 

15 return 0 ; 

16 }

5 CONTRÔLE & BOUCLES do...while 168 

57 

La boucle do...while 

Syntaxe : 

do 

instruction ; 

while (expression) ; 

do { 

/* bloc */ 

} while (expression) ; 

Cette troisième et dernière boucle effectue le test après l’exécution 

du bloc d’instructions (ou de l’instruction) 

↩→ Ceci implique que l’instruction (ou le bloc) sera toujours exécuté 

au moins une fois, contrairement aux cas du for et du while 

5 int n, min=1, max=15 ; 

6 

7 do { 

8 printf ("Donnez un nombre entier entre %d et %d : ", min, max) ; 

9 scanf ("%d", &n) ; 

10 } while (n < min || n > max) ; 

11 

12 printf ("Votre nombre est %d\n", n) ;




Pour écran 


Par chapitre 




Archive zip 

Exercices 






Manuels 


Plan 170 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




6 FONCTIONS Introduction 171 

→ En C toute instruction doit être dans une fonction. . . 

↩→ Il en faut donc au moins une dans tout programme, la fonction 

principale (main()) 

⇒ De plus, plutôt que d’avoir une unique fonction regroupant 

l’ensemble des traitements d’un programme, il est préférable 

”découper” en plus petits morceaux 

Quatre principaux avantages à cela : 

1 La lisibilité : la clarté du code augmente, puisqu’une sémantique est 

donnée à un ensemble d’instructions 

2 La facilité de développement, puisque le nombre de bugs diminue 

inévitablement une fois le découpage effectué ! (tests unitaires) 

3 Le développement coopératif : plusieurs personnes peuvent travailler 

sur un même programme sans savoir comment les autres morceaux 

fonctionnent en interne. On parle de modularité ou de paquetages 

4 La maintenabilité : il est plus facile d’intervenir sur un petit morceau 

de code que sur un gros !


Exemple : 

version-1fct.c 

1 #include 

2 


4 int a, b, c, x, y, w ; 

5 


7 scanf ("%d", &a) ; 

8 


10 scanf ("%d", &b) ; 

11 


13 scanf ("%d", &c) ; 

14 

15 x = (a < b) ? a : b ; 

16 x = (c < x) ? c : x ; 

17 

18 y = (a > b) ? a : b ; 

19 y = (c > y) ? c : y ; 

20 

21 w = y - x ; 

22 

23 /* ... */ 

24 

25 return 0 ; 

26 } 

version-4fct.c 

1 #include 

2 

3 int lire_nombre () { 

4 int n ; 


6 scanf ("%d", &n) ; 

7 return n ; 

8 } 

9 

10 int max (int n1, int n2, int n3) { 

11 int m ; 

12 return ((m = (n1 > n2 ? n1 : n2)) < n3) ? n3 : m ; 

13 } 

14 

15 int min (int n1, int n2, int n3) { 

16 int m ; 

17 return ((m = (n1 < n2 ? n1 : n2)) > n3) ? n3 : m ; 

18 } 

19 


21 int a, b, c, w ; 

22 

23 a = lire_nombre () ; 

24 b = lire_nombre () ; 

25 c = lire_nombre () ; 

26 w = max(a,b,c) - min(a,b,c) ; 

27 

28 /* ... */ 

29 

30 return 0 ; 

31 }


Principales conséquences (corollaires) : 

1 La factorisation du code : évite la duplication de certaines portions de 

code, en regroupant au sein d’une fonction les traitements identiques, 

et évite ainsi la redondance (dangereuse) 

2 La réutilisabilité du code : les fonctions écrites peuvent être utilisées 

à différents endroits dans le programme et réutilisées dans d’autres 

programmes 

61 

La fonction principale 

Le point d’entrée d’un programme est la fonction main : 


4 

5 /* bloc */ 

6 

7 return 0 ; 

8 } 


4 

5 printf ("Bienvenue dans %s\n", argv[0]) ; 

6 printf ("Il y a %d argument%s\n", 

7 argc-1, 

8 argc>2 ? "s" : "") ; 

9 

10 return 0 ; 

11 }

6 FONCTIONS Définition 174 

62 

Définition d’une fonction 

Une fonction est définie par : 

1 son nom 

2 son type de retour 

3 ses arguments 

4 et son bloc d’instructions 

La syntaxe pour définir une fonction est la suivante : 

SYNONYMES 

Routine : fonctions 

bas-niveau, micro 

électronique, temps réel 

(appelée régulièrement par 

une horloge) 

Procédure : fonction qui ne 

retourne pas de résultat 

(PASCAL, ADA, . . . ) 

type_de_retour nom_de_fonction (arguments) { 

/* DECLARATIONS */ 

/* INSTRUCTIONS */ 

return expression ; 

}

6 FONCTIONS Définition 175 

→ La partie arguments est soit : 

1 rien du tout (fonction sans paramètre), i.e. void, 

2 soit une liste de paramètres, séparés par des virgules 

où un paramètre est composé d’un type et d’un nom de variable 

→ Le type de retour est soit : 

1 rien du tout (une procédure), i.e. void, 

2 soit un type de base ou un type structuré 

Exemples : 

11 void trait (void) { 

12 printf ("-=-=-=-=-=-=-=-=-=-\n") ; 

13 } 

14 

15 void afficher_nombre (int n) { 

16 printf ("Votre nombre : %d\n", n) ; 

17 } 

18 

19 int saisir_nombre () { 

20 int n ; 

21 printf ("Donnez nombre : ") ; 

22 scanf ("%d", &n) ; 

23 return n ; 

24 } 

26 void nl () { 

27 printf ("\n") ; 

28 } 

29 

30 int carre (int n) { 

31 return n * n ; 

32 } 

33 

34 char pair (int n) { 

35 return (n % 2) == 0 ; 

36 } 

37 

38 int max (int n1, int n2) { 

39 return n1 > n2 ? n1 : n2 ; 

40 }

6 FONCTIONS Prototype 176 

Le nom, le type de retour et les types des arguments spécifient 

comment la fonction doit être appelée 

↩→ on parle alors du PROTOTYPE de la fonction 

Exemples : 

3 void trait (void) ; 

4 void afficher_nombre (int n) ; 

5 int saisir_nombre () ; 

6 void nl () ; 

7 int carre (int n) ; 

8 char pair (int n) ; 

9 int max (int n1, int n2) ; 

Pour qu’une fonction puisse être appelée, il faut que le compilateur 

connaisse son prototype au préalable 

↩→ Le prototype d’une fonction est connu par le compilateur soit : 

1 parce-que la fonction a été définie avant l’appel, 

2 soit parce-que son prototype a été déclaré avant l’appel 

RMQ : Pas nécessaire de connaître le code de la fonction avant l’appel

6 FONCTIONS Prototype 177 

Un exemple : 

version1-lineaire.c 

1 #include 

2 

3 /** Codes des fonctions */ 

4 


6 int n ; 


8 scanf ("%d", &n) ; 

9 return n ; 

10 } 

11 



14 } 

15 


17 return n1 > n2 ? n1 : n2 ; 

18 } 

19 



22 int a, b, c ; 

23 a = saisir_nombre() ; 

24 b = saisir_nombre() ; 

25 c = carre (max (a, b)) ; 

26 /* ... */ 

27 return 0 ; 

28 } 

version2-prototype.c 

1 #include 

2 

3 /** Declarations des fonctions */ 

4 int saisir_nombre () ; 

5 int carre (int n) ; 

6 int max (int n1, int n2) ; 

7 



10 int a, b, c ; 

11 a = saisir_nombre() ; 

12 b = saisir_nombre() ; 

13 c = carre (max (a, b)) ; 

14 /* ... */ 

15 return 0 ; 

16 } 

17 

18 /** Codes des fonctions */ 

19 


21 int n ; 


23 scanf ("%d", &n) ; 

24 return n ; 

25 } 

26 



29 } 

30 


32 return n1 > n2 ? n1 : n2 ; 

33 }

6 FONCTIONS Appel 178 

Doit être bien clair (dans votre esprit) ! Ne pas confondre : 

1 le moment où l’on déclare/défini une fonction 

2 et le moment où l’on appelle une fonction 

→ Le code déclaré dans une fonction ne déclenche aucune 

d’exécution 

→ Le code déclaré dans une fonction ne fait que définir une suite 

d’actions à exécuter dans le cas où la fonction serait appelée 

→ Le code d’une fonction ne s’exécutera que lorsque la fonction aura 

été appelée par la fonction main() ou (indirectement) par une autre 

fonction qui aura été appelée par la fonction main() 

⇒ Une fonction peut être appelée plusieurs fois, mais n’est définie 

qu’une seule fois


Exemple : le programme suivant. . .ne fait rien ! 

nothing.c 

1 #include 

2 


4 int n ; 


6 scanf ("%d", &n) ; 

7 return n ; 

8 } 

9 


11 return n1 > n2 ? n1 : n2 ; 

12 } 

13 

14 int demander () { 

15 int a, b, c ; 

16 a = saisir_nombre () ; 

17 b = saisir_nombre () ; 

18 c = max (a, b) ; 

19 printf ("Le plus grand est %d\n", c) ; 

20 return c ; 

21 } 

22 


24 

25 return 0 ; 

26 }


Exemple : appels multiples de fonctions 

calls.c 

1 #include 

2 


4 int n ; 


6 scanf ("%d", &n) ; 

7 return n ; 

8 } 

9 

10 int carre (int n) { return n * n ; } 

11 

12 char pair (int n) { return (n % 2) == 0 ; } 

13 

14 void afficher (int n) { 

15 printf ("%d est %s et son carre vaut %d\n", n, pair(n) ? "pair" : "impair", carre(n)) ; 

16 } 

17 


19 int a, b, c ; 

20 a = saisir_nombre () ; 

21 b = saisir_nombre () ; 

22 afficher (a) ; 

23 afficher (b) ; 

24 afficher (4) ; 

25 c = carre (24) ; 

26 printf ("%d + %d + %d = %d\n", a, b, c, a+b+c) ; 

27 return 0 ; 

28 }

6 FONCTIONS Passage des paramètres 181 

RMQ : Que ce soit au moment de la déclaration ou au moment de 

l’appel, le nom d’une fonction doit TOUJOURS être suivit d’une paire 

de parenthèses, même dans le cas sans arguments (void) 

63 

Passage des paramètres par valeur 

Les arguments d’une fonction sont des copies locales 

Autrement dit, le mode de passage des paramètres est 

(uniquement) par valeur 

⇒ Ce point est crucial et source de bugs ! 

RMQ : Lié au fonctionnement des ordinateurs 

↩→ Chaque paramètre d’une fct se voit empiler 

par valeur dans la pile d’appel des fonctions 

↩→ Le code de la fonction va ensuite utiliser 

des variables locales 

↩→ Changement zone d’adressage mémoire. . .

6 FONCTIONS Passage des paramètres 182 

Exemple : 

echange-incorrect.c 

1 #include 

2 

3 /* NB: ne pas copier */ 

4 void echange (int a, int b) { 

5 int tmp = a ; /* (3) */ 

6 a = b ; /* (4) */ 

7 b = tmp ; /* (5) */ 

8 } 

9 


11 int i=10, j=5 ; /* (1) */ 

12 echange (i, j) ; /* (2) */ 

13 printf ("i=%d j=%d\n", i, j) ; /* (6) */ 

14 return 0 ; /* (7) */ 

15 } 

Lors de l’appel de la fonction echange(), à 

la ligne 12, c’est le contenu des variables i 

et j qui est copié respectivement dans les 

variables locales a et b

6 FONCTIONS Variables 183 

RMQ : Que penser des appels suivants ? Sont-ils corrects ? 

echange (3, 5) ; 

echange (i, 5) ; 

echange (3, j) ; 

64 

Retour sur les variables 

→ Les variables ont des durées de vie et des visibilités différentes, 

selon comment et où elles sont déclarées 

Elles peuvent être classées en 3 catégories : 

Visibilité/Portée Durée de vie 

Les variables locales Bloc Bloc 

Les variables globales Programme Programme 

Les variables statiques Bloc Programme


65 

Variable locale 

Une variable dont la déclaration est réalisée dans le corps d’une 

fonction, ou dans un bloc d’instructions (instructions délimitées par 

des accolades {}), est allouée dynamiquement dans la pile 

Il s’agit d’une variable locale (au comportement similaire à un 

paramètre d’une fonction) et dont la visibilité (portée) est limitée au 

bloc où elle est déclarée 

Sa durée de vie est limitée au bloc ou à la fonction où elle est 

déclarée 

3 int compteur (void) { 

4 int i = 0 ; /* variable locale */ 

5 return ++i ; 

6 } 

7 


9 printf ("cpt=%d\n", compteur()) ; 



12 return 0 ; 

13 } 

→ Ici, la variable i n’existe pas en dehors 

de la fonction compteur() 

↩→ La valeur retournée sera toujours 1


66 

Variable globale 

À l’opposé des variables locales existent les variables globales 

Ce sont celles allouées dans le programme et qui seront créées 

par le compilateur (donc allocation statique) 

Leur visibilité (portée) est totale (i.e. de partout) et leur durée de 

vie celle du programme 

3 int i = 0 ; /* variable globale */ 

4 



7 } 

8 





13 printf ("i vaut %d\n", i) ; 

14 return 0 ; 

→ La valeur retournée par la fonction 

sera 1, puis 2, 3 . . . 

↩→ Cependant ATTENTION, car i est modifiable de partout. . . 

⇒ À manipuler avec précaution (dangereux)


RMQ : Une variable globale peut également être visible dans des 

fonctions écrites dans d’autres fichiers sources du programme 

↩→ Pour cela, il faut redéclarer son prototype dans l’autre fichier en 

utilisant le mot clé extern 

↩→ La variable ne sera pas dupliquée, mais sera trouvée lors de 

l’édition des liens 

main.c 

1 #include 

2 

3 /* Variables globales */ 

4 extern int i ; 

5 

6 /* Declarations de fonctions */ 

7 int compteur () ; 

8 int megacompteur () ; 

9 




13 printf ("cpt=%d\n", megacompteur()) ; 

14 printf ("i vaut %d\n", i) ; 

15 return 0 ; 

16 } 

compteurs.c 

1 /* Variables globales */ 

2 int i = 0 ; 

3 

4 /* Code des fonctions */ 

5 



8 } 

9 

10 int megacompteur (void) { 

11 return i += 2 ; 

12 } 

Gestion compliquée. . . 

INTERDIT ! Sauf cas spéciaux


67 

Variable statique 

Une variable statique est une variable dont la déclaration est 

précédée du mot clé static 

Elle ressemble à une variable globale, mais avec une visibilité 

(portée) réduite 

Sa visibilité est restreinte au fichier ou au bloc la contenant 

Sa durée de vie est celle du programme 


4 static int i = 0 ; /* variable 

statique */ 


6 } 

7 





12 return 0 ; 

13 } 

→ La valeur retournée par la fonction 

sera 1, puis 2, 3 . . .


68 

→ Un nom de 

variable peut 

servir plusieurs 

fois 

Ceci est 

évident pour les 

variables locales 

et/ou statiques, 

déclarées dans 

des blocs disjoints 

Mais ceci est 

également vrai 

pour des bloc 

inclus. . . 

Surcharge des noms de variables 

portee-variables.c 

3 int i = 0 ; /* i variable globale */ 

4 

5 int compteur1 (void) { 


7 } 

8 

9 int compteur2 (void) { 

10 static int i = 0 ; /* i variable locale statique */ 


12 } 

13 


15 int i ; /* i variable locale, masque i globale */ 

16 

17 for (i=0 ; i


↩→ La portée d’une variable (de 

visibilité plus large) s’arrête 

lorsqu’une variable (de visibilité 

plus faible) portant le même nom 

est déclarée dans un sous-bloc


69 

Cas des tableaux 

Un tableau peut être argument d’une fonction, mais un tableau 

déclaré de manière statique (comme ci-dessous) ne peut pas être 

retourné par une fonction 

2 /* NB: ne compile pas */ 

3 int *reverse (int a[], int N) { 

4 int i, b[N] ; 

5 

6 for (i=0 ; i

6 FONCTIONS Récursivité 191 

610 

Récursivité 

En C, toute fonction peut être 

récursive, i.e. s’appeler elle-même 

Exemple : Calculer la factorielle 

Récursion : N! = N.(N − 1)! 

Cas d’arrêt : 0! = 1 

factorielle-rec.c 

1 #include 

2 

3 int factorielle (int n) { 

4 if (n == 0) 

5 return 1 ; 

6 else 

7 return n * factorielle (n-1) ; 

8 } 

9 


11 int a ; 

12 a = factorielle (3) ; 

13 printf ("3! = %d\n", a) ; 

14 return 0 ; 

15 }

6 FONCTIONS Récursivité 192


Ainsi, l’appel récursif consiste à empiler des valeurs dans la pile 

d’appel de fonction (qui pourraient être des variables locales dans un 

contexte itératif) 

Le mécanisme récursif engendre et utilise des variables 

temporaires masquées, ralentissant l’exécution par rapport à ce que 

l’on pourrait croire 

Néanmoins, la facilité d’utilisation de ce processus le rend utile et 

fort appréciable pour des fonctions complexes, d’autant que le coût 

des appels d’une fonction devient négligeable si son code est 

conséquent (le gain en temps de développement étant d’autant plus 

important) 

L’intérêt des fonctions récursives est dans la clarté du code qui 

peut en découler 

RMQ : Clairement, toute fonction récursive peut aussi s’écrire de 

manière itérative, et vice versa (bijectif)


Exemple : Quicksort 

4 void quicksort (int a[], int debut, int fin) { 

5 if (debut < fin) { 

6 int tmp ; 

7 int i=debut, j=fin, pivot=a[(debut+fin)/2] ; 

8 

9 /* Partitionnement */ 

10 do { 

11 while (a[i] < pivot) 

12 i++ ; 

13 

14 while (a[j] > pivot) 

15 j-- ; 

16 

17 if (i < j) { 

18 tmp = a[i] ; 

19 a[i] = a[j] ; 

20 a[j] = tmp ; 

21 } 

22 i++; 

23 j--; 

24 } while (i < j) ; 

25 

26 /* INVARIANT : a[debut,i] = pivot */ 

28 

29 quicksort (a, debut, j) ; 

30 quicksort (a, i, fin) ; 

31 } 

32 } 

L’appel récursif est évident 

pour écrire Quicksort, puisque 

quicksort() s’appelle 

elle-même sur les portions non 

encore partitionnées du tableau 

La récursion s’arrête quand 

tableau vide (debut >= fin) 

RMQ : Fonctionne car a[] est 

un tableau (donc une adresse 

mémoire vers une zone de cases 

consécutives) 

↩→ ainsi, les sous-appels de 

fonctions travaillent effectivement 

tous sur le même tableau !

Plan 195 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




7 POINTEURS Introduction 196 

Les pointeurs occupent une place prépondérante en C pour deux 

raisons principales : 

Le besoin en terme d’algorithmique (passage d’arguments par 

adresse, liste chaînée, arbres, . . .) 

L’efficacité du code 

Un pointeur = une variable qui contient une adresse mémoire 

(Ex : l’adresse d’une autre variable ou des cases d’un tableau) 

Le problème des pointeurs pour le débutant tient plus dans la 

difficulté à comprendre le fonctionnement à cause d’une syntaxe 

concise et déroutante, plutôt que dans la notion qui est derrière. . . 

RMQ : Déjà vu implicitement dans les tableaux 

5 int a[5] ; 

6 *a = 2 ; 

7 *(a+1) = 4 ; 

8 *(a+2) = 5 ; 

9 *(a+3) = 1 ; 

10 *(a+4) = 3 ;

7 POINTEURS Généralités 197 

71 

Généralités 

Comme toute variable, un pointeur = 

un nom 

un type : le type de variable pointée 

une valeur : l’adresse de la variable pointée 

un espace mémoire 

Un pointeur se déclare comme suit : 

type_pointé *nom_pointeur ; 

Exemples : 

4 int *pt ; 

5 char *s ; 

6 double *x ; 

RMQ : La déclaration d’un pointeur reste somme 

toute quelque-chose d’assez imprécis 

↩→ Selon l’utilisation que le programmeur en fera, ces 

pointeurs pourront ensuite désigner aussi bien 

l’adresse d’une variable que celle d’un tableau


L’opérateur & précédant le nom d’une variable permet de 

récupérer l’adresse de celle-ci 

RMQ : Déjà vu pour appeler scanf() 

L’opérateur * précédant le nom d’un pointeur permet d’accéder 

au contenu de la variable pointée 

↩→ On parle alors de déréférencer le pointeur 

RMQ : Ne pas confondre avec l’étoile utilisée lors de la déclaration 

Exemple : 

4 int *ptr, i, j ; /* (1) */ 

5 

6 ptr = &i ; /* (2) */ 

7 *ptr = 10 ; /* (3) */ 

8 printf ("i=%d ptr=%x\n", i, ptr) ; 

9 

10 ptr = &j ; /* (4) */ 

11 *ptr = i + 1 ; /* (5) */ 

12 printf ("j=%d ptr=%x\n", j, ptr) ;


Ce qui nuit à la compréhension des pointeurs, c’est qu’une 

variable pointeur a un espace mémoire et donc une adresse mémoire 

comme toute variable normale. . . il est donc possible de définir un 

pointeur de pointeur, etc. . . . ce qui conduit à des notations lourdes 

Exemple : 

4 int i, *p, **pp ; 

5 

6 pp = &p ; 

7 *pp = &i ; /* p = &i */ 

8 **pp = 10 ; /* i = 10 */ 

9 

10 printf ("i = %d\n", i) ; 

11 printf ("*p = %d\n", *p) ; 

12 printf ("**pp = %d\n", **pp) 

; 

↩→ Ce petit bout de code, a priori farfelu, est en fait assez simple : 

l6 : pp est un pointeur sur la variable p 

l7 : la variable pointée par pp (c.à.d p) reçoit l’adresse de la variable i 

l8 : on met 10 dans la variable i par une double indirection. . .

7 POINTEURS Passage des paramètres 200 

72 

Passage des paramètres par adresse 

Exemple : 

→ Reprenons la fonction echange() 

↩→ Elle ne fonctionnait pas à cause du fait que 

le passage des paramètres des fonctions se fait 

par valeur (passage par copie) 

3 /* NB: ne pas copier */ 

4 void echange (int a, int b) { 

5 int tmp = a ; 

6 a = b ; 

7 b = tmp ; 

8 } 

Solution : 

→ Une solution correcte consiste à passer en 

paramètre, non pas les valeurs à échanger, 

mais les adresses des variables à permuter 

⇒ Manipulation de pointeurs 

3 void echange (int *a, int *b) { 

4 int tmp = *a ; 

5 *a = *b ; 

6 *b = tmp ; 

7 }

7 POINTEURS Passage des paramètres 201 

echange-pointeurs.c 

1 #include 

2 

3 void echange (int *a, int *b) { 

4 int tmp = *a ; /* (3) */ 

5 *a = *b ; /* (4) */ 

6 *b = tmp ; /* (5) */ 

7 } 

8 


10 int i=10, j=5 ; /* (1) */ 

11 echange (&i, &j) ; /* (2) */ 

12 printf ("i=%d j=%d\n", i, j) ; /* (6) */ 

13 return 0 ; /* (7) */ 

14 } 

Dans cette nouvelle version, la fonction 

echange() prend maintenant en paramètres 

deux pointeurs d’entiers (de type int *) 

contenant les adresses des variables dont le 

contenu doit être échangé

7 POINTEURS Mémoire dynamique 202 

73 

Mémoire dynamique 

La bibliothèque stdlib.h définit les fonctions de gestion mémoire 

suivantes (entre nombreuses autres) : 

void *malloc (size t size) ; 

void free (void *) ; 

Elles permettent respectivement de réserver (allouer) puis libérer 

(désallouer) des espaces mémoire dynamiquement (i.e. durant 

l’exécution du programme)


Exemple : allocation dynamique d’un tableau de 5 entiers 

allocation-tableau.c 

1 #include 

2 #include 

3 


5 int *tab, i ; 

6 

7 /* Demander d’allouer de la memoire (5x4 = 20 octets) */ 

8 tab = malloc (5 * sizeof(int)) ; 

9 

10 if (tab == NULL) { 

11 fprintf (stderr, "Error: memory allocation failed\n") ; 

12 exit (-1) ; 

13 } 

14 

15 /* Remplir le tableau */ 

16 for (i=0 ; i


Ligne 5 : Après la 

déclaration des 

variables 

Ligne 8 : Après appel 

à malloc() 

Lignes 16-17 : Après 

affectation des cases 

Ligne 25 : Après appel 

à free()

7 POINTEURS Opérateurs 205 

74 

Opérateurs 

Les opérations suivantes s’appliquent aux pointeurs : 

Addition : Pointeur × Entier ↦−→ Pointeur 

Soustraction : Pointeur × Entier ↦−→ Pointeur 

Soustraction : Pointeur × Pointeur ↦−→ Pointeur 

Comparaison : Pointeur × Pointeur ↦−→ Booléen 

1 Addition Pointeur × Entier ↦−→ Pointeur (+ , ++ et +=) 

4 int *p, i, tab[10] ; 

5 

6 /* Initialiser tab[0...9] */ 

7 for (i=0, p=tab ; i

7 POINTEURS Opérateurs 206 

2 Soustraction Pointeur × Entier ↦−→ Pointeur (− , −− et −=) 

17 for (i=9, p=tab+9 ; i>=0 ; i--) 

18 *(p-i) = i ; 

3 Soustraction Pointeur × Pointeur ↦−→ Pointeur (−) 

27 for (i=0, p=tab+10 ; p-tab ; i++) 

28 *--p = i ; 

37 for (p=tab+9 ; (p+1)-tab ; p--) 

38 *p = p-tab ; 

4 Comparaison Pointeur × Pointeur ↦→ Booléen 

(== ! = < = >) 

47 for (p=tab+9 ; p+1>tab ; p--) 

48 *p = p-tab ; 

RMQ : Uniquement entre pointeurs (opérateurs sur le même type)

Plan 207 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




8 STRUCTURES Principes 208 

81 

Principes généraux 

En C, une structure (enregistrement, record) est un regroupement 

de une ou plusieurs variables, de types quelconques et 

éventuellement différents 

L’intérêt réside dans une manipulation plus facile de données liées 

(sémantiquement), surtout dans les programmes de tailles 

importantes 

Cela permet surtout de représenter la notion d’entité (ou d’objet), 

justement en explicitant la liaison existant au niveau sémantique 

entre différentes variables 

Exemples : 


4 double real ; 

5 double imag ; 

6 } ; 

8 struct point { 

9 double x ; 

10 double y ; 

11 } ; 

13 struct droite { 

14 double a ; 

15 double b ; 

16 } ;


Pour travailler avec des 

variables structurées, 

l’opérateur ”.” permet d’accéder 

aux éléments de la structure 

Ce code affiche : 

Une structure peut 

regrouper des variables de 

types différents 

RMQ : On dit les champs de la 

structure 

(Ex : la structure rectangle 

possède 3 champs) 




6 } ; 

7 


9 struct complexe c, b ; 

10 

11 c.real = 2. ; 

12 c.imag = 0. ; 

13 

14 printf ("c = (%.2f;%.2f)\n", c.real, c.imag) ; 

15 

16 return 0 ; 

17 } 


4 double x, y ; 

5 } ; 

6 

7 struct rectangle { 

8 struct point center ; 

9 double width, height ; 

10 } ; 

11 


13 struct rectangle Rect ; 

14 

15 /* Initialiser le rectangle */ 

16 Rect.center.x = 0. ; 

17 Rect.center.y = 0. ; 

18 Rect.width = 5. ; 

19 Rect.height = 2. ; 

20


Autre exemple : 

1 #include 

2 

3 enum GENDER { FEMALE, MALE } ; 

4 

5 struct date { 

6 unsigned char d ; 

7 unsigned char m ; 

8 unsigned int y ; 

9 } ; 

10 

11 struct user { 

12 char *name ; 

13 char *password ; 

14 struct date birthday ; 

15 enum GENDER gender ; 

16 } ; 

17 


19 struct user playerOne, playerTwo ; 

20 

21 playerOne.name = strdup("Me"); 

22 playerOne.birthday.d = 26 ; 

23 playerOne.birthday.m = 7 ; 

24 playerOne.birthday.y = 1982 ; 

25 playerOne.gender = MALE ; 

26 playerOne.name = strdup("You"); 

27 /*...*/ 

1 #include 

2 

3 typedef enum GENDER { FEMALE, MALE } Gender ; 

4 

5 typedef struct date { 

6 unsigned char d ; 

7 unsigned char m ; 

8 unsigned int y ; 

9 } Date ; 

10 

11 typedef struct user { 

12 char *name ; 

13 Date birthday ; 

14 Gender gender ; 

15 } User ; 

16 


18 User playerOne, playerTwo ; 

19 

20 playerOne.name = strdup("Me"); 

21 playerOne.birthday.d = 26 ; 

22 playerOne.birthday.m = 7 ; 

23 playerOne.birthday.y = 1982 ; 

24 playerOne.gender = MALE ; 

25 playerOne.name = strdup("You"); 

26 /*...*/ 

RMQ : Utiliser typedef pour définir un nouveau type et éviter d’avoir à 

écrire struct partout

8 STRUCTURES Opérations 211 

Initialisation 


4 double x, y ; 

5 } ; 

6 


8 struct point center ; 

9 double width, height ; 

10 } ; 

11 


13 struct point P = {10., 10.} ; 

14 struct rectangle Rect = {{0., 0.}, 5., 2.} ; 

15 /*...*/ 

16 return 0 ; 

17 } 

Copie 

RMQ : Aucun autre des 

opérateurs n’est possible 

(+, −, , ==, ! =, . . .) 

↩→ Il faut définir des fonctions 

qui accéderont proprement 

aux champs 




6 } ; 

7 


9 struct complexe a, b ; 

10 

11 a.real = 2. ; 

12 a.imag = 0. ; 

13 b = a ; 

14 

15 printf ("a = (%.2f;%.2f)\n", a.real, a.imag) ; 

16 printf ("b = (%.2f;%.2f)\n", b.real, b.imag) ; 

17 return 0 ; 

18 }

8 STRUCTURES Fonctions & structures 212 

82 

Fonctions et structures 

Les variables structurées peuvent être passées en paramètres des 

fonctions et aussi retournées par des fonctions 

Exemple : 

Une fonction qui calcule 

l’aire d’un rectangle 


4 int width, height ; 

5 } ; 

6 

7 int rectangle_aire (struct rectangle rect) { 

8 return rect.width * rect.height ; 

9 } 

10 


12 struct rectangle R1 ; 

13 int a ; 

14 

15 R1.width = 5 ; 

16 R1.height = 2 ; 

17 

18 a = rectangle_aire (R1) ; 

19 

20 printf ("L’aire du rectangle est %d\n", a) ; 

21 return 0 ; 

22 }


Exemple : addition et soustraction des complexes 


4 double real, imag ; 

5 } ; 

6 

7 struct complexe complexe_ajouter (struct complexe a, struct complexe b) { 

8 struct complexe res = a ; /* affectation : copie les champs */ 

9 res.real += b.real ; 

10 res.imag += b.imag ; 

11 return res ; /* retourne une structure */ 

12 } 

13 

14 struct complexe complexe_soustraire (struct complexe a, struct complexe b) { 

15 return (struct complexe) {a.real - b.real, a.imag - b.imag} ; 

16 } 

17 


19 struct complexe a, b, c ; 

20 

21 a.real = 1.41421 ; 

22 a.imag = 1.41421 ; 

23 

24 b.real = 0. ; 

25 b.imag = 1. ; 

26 

27 c = complexe_ajouter (a, b) ; 

28 


30 

31 return 0 ; 

32 }


Les paramètres des fonctions sont copiés dans une pile 

↩→ Cette copie peut être coûteuse en temps d’exécution, et parfois 

bien inutile 

⇒ On privilégie donc, pour des structures de tailles importantes, le 

passage par adresse. . . et donc les pointeurs 



5 } ; 

6 

7 void rectangle_afficher (struct rectangle *rect) { 

8 printf ("Rectangle [Largeur=%d;Hauteur=%d]\n", (*rect).width, (*rect).height) ; 

9 } 

10 

11 int rectangle_perimetre (struct rectangle *rect) { 

12 return (*rect).width * 2 + (*rect).height * 2 ; 

13 } 

14 


16 struct rectangle R1 ; 

17 int p ; 

18 R1.width = 5 ; 

19 R1.height = 2 ; 

20 p = rectangle_perimetre (&R1) ; /* RMQ: on donne l’adresse de R1 */ 

21 rectangle_afficher (&R1) ; /* RMQ: on donne l’adresse de R1 */ 

22 printf ("Le perimetre vaut %d\n", p) ; 

23 return 0 ; 

24 }


Déréférencement des champs d’une structure 

Lorsqu’on a un pointeur vers une structure : 

struct rectangle *rect ; 

Pourquoi les parenthèses pour déréférencer ? 

(*rect).width 

⇒ À cause de la priorité des opérateurs : 

le point est plus prioritaire que l’étoile 

Au fil des ans, cette notation a été jugée pénible, aussi une nouvelle 

forme d’écriture a été ajoutée au langage : 

rect->width 

⇒ Ainsi, la flèche permet de déréférencer 

les champs de la structure pointée


L’écriture à de multiples 

reprises du mot clé 

struct également est 

assez pénible. . . 

→ Une alternative existe : 

définir un nouveau type, que 

l’on utilisera en lieu et place 

de la structure. . . 


4 double real, imag ; 

5 } ; 

6 

7 typedef struct complexe Complexe ; 

8 

9 /* Addition de 2 complexes */ 

10 Complexe CAdd (Complexe a, Complexe b) { 

11 a.real += b.real ; 

12 a.imag += b.imag ; 

13 return a ; 

14 } 

15 

16 /* Equivalent du += pour complexes */ 

17 Complexe CCAdd (Complexe *a, Complexe b) { 

18 a->real += b.real ; 

19 a->imag += b.imag ; 

20 return *a ; 

21 } 

22 


24 Complexe a, b, c ; 

25 

26 a.real = 1.41421 ; 

27 a.imag = 1.41421 ; 

28 

29 b.real = 0. ; 

30 b.imag = 1. ; 

31 

32 c = CAdd (a, b) ; 


34 

35 CCAdd (&c, b) ; 


37

8 STRUCTURES Tableaux & structures 217 

RMQ : typedef peut servir aussi à définir des types à partir d’autres 

choses que des structures. . . Par exemple, les entiers courts non signés, 

les octets. . . 

typedef unsigned short ushort ; 

typedef unsigned char octet ; 

83 

Tableaux et structures 

Comme pour les types de base, il est possible de créer des tableaux 

de structures : 

rectangles-tab5.c 



5 } ; 

6 

7 int rectangle_aire (struct rectangle rect) { 

8 return rect.width * rect.height ; 

9 } 

10 

11 void rectangle_afficher (struct rectangle rect) { 

12 printf ("rectangle [%d;%d]\n", rect.width, rect.height) ; 

13 }

8 STRUCTURES Tableaux & structures 218 

rectangles-tab5.c (suite et fin) 

14 


16 struct rectangle tab[5] ; 

17 int i, aire_totale ; 

18 

19 /* Initialisation */ 

20 for (i=0 ; i

8 STRUCTURES Structure récurrente 219 

84 

Les structures auto-référencielles 

Ou structures récurrente : des structures qui ont au moins un champs 

qui est du type même de la structure 

Exemples : 

Coder des arbres binaires 

22 typedef struct node *Node ; 

23 

24 struct node { 

25 int value ; /* Valeur du noeud */ 

26 Node lson ; /* Fils gauche */ 

27 Node rson ; /* Fils droit*/ 

28 } ; 

29 

30 typedef struct tree { 

31 Node root ; 

32 } Tree ; 

Coder des listes 

Simplement chaînées 

3 struct list { 


5 struct list *next ; /* Element suivant */ 

6 } ; 

7 

8 typedef struct list *List ; 

Doublement chaînées 

12 struct list { 


14 struct list *next ; /* Element suivant */ 

15 struct list *last ; /* Element precedent */ 

16 } ; 

17 

18 typedef struct list *List ;

Plan 220 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




9 LE PRÉPROCESSEUR Introduction 221 

Le préprocesseur C permet la 

définition de macros, qui vont être 

traitées avant la phase de 

compilation proprement dite, dans 

la phrase de préprocess 

Le préprocesseur C permet 

ainsi de faire de la compilation 

conditionnelle, d’inclure des 

fichiers d’entêtes, de définir des 

constantes 

→ La phase de préprocess est un 

simple traitement sur des fichiers 

textes (ne correspond pas à des 

instructions qui seraient exécutées 

par le futur programme)

9 LE PRÉPROCESSEUR Macro-constantes 222 

→ La phase de préprocess exécute les lignes commençant par un # 

RMQ : L’option -E de GCC permet de visualiser le résultat de la 

phase de préprocess 

gcc -Wall -ansi -E main.c -o programme.exe 

↩→ Attention, avec l’option -E, la compilation n’a pas lieu 

91 

Les macro-constantes 

Elles se définissent par le mot clé #define 

L’intérêt est qu’il n’y a pas de définition de nouvelle variable, les 

valeurs des macro-constantes étant écrites dans le code avant 

compilation

9 LE PRÉPROCESSEUR Macro-constantes 223 

Exemple 

→ Le code suivant : 

1 #define MAX 100 

2 


4 int T[MAX] ; /* Definition du tableau T */ 

5 int i ; /* Indice de parcours */ 

6 

7 for (i=0 ; i

9 LE PRÉPROCESSEUR Paquetages 224 

92 

Les paquetages 

Concept : regrouper les structures et fonctions (et éventuellement les 

variables globales (extern) et locales (static)) par thèmes 

Un paquetage regroupe 2 types de fichiers, différents par leur 

extension de nom : 

1 fichier.c : l’implantation (ou fichier source), contient le code 

et les variables 

2 fichier.h : l’interface du paquetage (ou fichier d’entête), 

contient les déclarations des prototypes des fonctions du 

paquetage, éventuellement des définitions types (structures) et 

des variables globales externes, et qui sera par la suite inclue 

dans les implantations (fichiers sources) utilisatrices


Un fichier interface (ou fichier d’entête) commence toujours par les 

lignes : 

#ifndef 

#define 

XXXX H 

XXXX H 

↩→ En remplaçant les XXXX par le nom du paquetage 

Et termine toujours par la ligne : 

#endif 

RMQ : Ce mécanisme est fait pour palier aux possibles inclusions 

multiples


Exemple : 

Un (mini-)paquetage 

de géométrie 

L’interface → 

boolean.h 

1 #ifndef __BOOLEAN_H 

2 #define __BOOLEAN_H 

3 

4 typedef enum BOOLEAN { FALSE, TRUE} BOOLEAN ; 

5 

6 #endif /* __BOOLEAN_H */ 

geometrie.h 

1 #ifndef __GEOMETRIE_H 

2 #define __GEOMETRIE_H 

3 

4 #include "boolean.h" 

5 

6 typedef struct point { 

7 int x, y ; 

8 } point ; 

9 

10 typedef struct droite { 

11 double a, b ; 

12 BOOLEAN verticale ; 

13 int x ; 

14 } droite ; 

15 

16 point point_lire () ; 

17 double point_distance (point p1, point p2) ; 

18 droite droite_calculer (point p1, point p2) ; 

19 

20 #endif /* __GEOMETRIE_H */


L’implantation→ geometrie.c 

1 #include /* printf() scanf() */ 

2 #include /* sqrt() */ 

3 #include "geometrie.h" 

4 

5 point point_lire () { 

6 point res ; 

7 printf (" Donnez l’abscisse : ") ; 

8 scanf ("%d", &res.x) ; 

9 printf (" Donnez l’ordonnee : ") ; 

10 scanf ("%d", &res.y) ; 


12 } 

13 

14 double point_distance (point p1, point p2) { 

15 return sqrt ((p1.x-p2.x) * (p1.x-p2.x) + (p1.y-p2.y) * (p1.y-p2.y)) ; 

16 } 

17 

18 droite droite_calculer (point p1, point p2) { 

19 droite res ; 

20 if (p1.x == p2.x) { 

21 res.verticale = TRUE ; 

22 res.x = p1.x ; 

23 } 

24 else { 

25 res.verticale = FALSE ; 

26 res.a = (double)(p1.y - p2.y) / (p1.x - p2.x) ; 

27 res.b = p1.y - res.a * p1.x ; 

28 } 


30 }


Un premier programme utilisant le paquetage : 

main.c 

1 #include 


3 


5 point P = {9, 8} ; 

6 point Q = {2, 3} ; 

7 droite D ; 

8 double dist ; 

9 

10 D = droite_calculer (P, Q) ; 

11 dist = point_distance (P, Q) ; 

12 

13 if (D.verticale) 

14 printf ("Equation x = %d\n", D.x) ; 

15 else 

16 printf ("Equation y = %.2f x + %.2f\n", D.a, D.b) ; 

17 

18 printf ("Distance %.2f\n", dist) ; 

19 

20 return 0 ; 

21 } 

gcc -Wall -ansi -lm main.c geometrie.c -o calculs.exe


Un autre programme utilisant aussi le paquetage : 

main2.c 

1 #include 


3 


5 point P, Q ; 

6 droite D ; 

7 

8 printf ("\n-=- Coordonnees du point P -=-\n") ; 

9 P = point_lire () ; 

10 

11 printf ("\n-=- Coordonnees du point Q -=-\n") ; 

12 Q = point_lire () ; 

13 

14 printf ("\n") ; 

15 

16 D = droite_calculer (P, Q) ; 

17 

18 if (D.verticale) 

19 printf ("Equation x = %d\n", D.x) ; 

20 else 

21 printf ("Equation y = %.2f x + %.2f\n", D.a, D.b) ; 

22 

23 return 0 ; 

24 } 

gcc -Wall -ansi -lm main2.c geometrie.c -o calculs2.exe


Relations de dépendance entre les fichiers : 

Pour utiliser le (mini-)paquetage 

de géométrie, les fichiers 

sources main.c et main2.c 

doivent inclure l’interface 

geometrie.h 

Le fichier d’implantation 

geometrie.c doit inclure 

l’interface geometrie.h afin de 

connaître les déclaration des 

types structurés point et 

droite, mais également pour 

assurer que les prototypes des 

fonctions seront respectés 

Le fichier geometrie.h inclue 

le fichier d’entête boolean.h 

pour connaître le type énuméré 

BOOLEAN

Plan 231 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




10 BIBLIOTHÈQUE STANDARD Introduction 232 

→ Le C possède très peu de mots clés de langage 

→ Par contre, pour permettre son utilisation véritable, il existe une 

bibliothèque standard, normalisée, permettant de multiples actions : 

Les entrées/sorties 

Les mathématiques (de base) 

Des traitements sur les chaînes de caractères 

. . . 

La bibliothèque standard ANSI contient l’ensemble des librairies 

suivantes : 

 

 

 

 

Seulement certains de ces modules seront présentés ici (Par 

exemple, il est encore beaucoup trop tôt pour et 

)

10 BIBLIOTHÈQUE STANDARD 233 

101 

Les entrées sorties : 

Rappel : un flot (ou stream) est associé à une source/destination 

de données (clavier, écran, disque, . . .) 

Les flots peuvent être de deux sortes : texte ou binaire 

Un flot doit être ouvert avant utilisation, fermé après 

Ici, le flot est un pointeur sur une structure de FILE 

Trois flots sont ouverts par défaut : stdin, stdout et stderr 

Nous avons déjà exposé les fonctions suivantes (ouverture et 

fermeture de flots) : 

FILE *fopen (const char *path, const char *mode) ; 

int fclose (FILE *stream) ; 

⇒ D’autres fonctions de manipulation de fichiers existent


int fflush (FILE *stream) ; 

↩→ Provoque l’écriture des données mises en tampon (indéfini sur un 

flot d’entrée). Retourne 0, ou EOF si erreur 

int remove (const char *path) ; 

↩→ Destruction pure et simple d’un fichier ! Retourne 0 si erreur 

int rename (const char *oldpath, const char *newpath) ; 

↩→ Change le nom d’un fichier donné. Retourne 0 si erreur 

int setvbuf(FILE *stream, char *buf, int mode, size t sz); 

↩→ Permet de contrôler le tamponnage d’un flot, uniquement avant la 

1 re lecture/écriture. Le mode IOFBD provoque un tamponnage 

complet, IOLBF par ligne, IONBF inexistant. Si buf est différent de 

NULL, alors il sert de tampon, de taille size. Retourne une valeur 

non nulle si erreur


Nous avons déjà étudié les fonction d’E/S classiques (printf, 

scanf, fprintf, etc.) 

Très pratiques en général, elles sont cependant pénibles car 

limitées aux informations textuelles formatées 

D’autres fonctions permettent des lectures/écritures binaires 

size t fread (void *ptr, size t size, size t n, FILE *stream); 

↩→ Lit sur stream au plus n éléments de taille size octets et les 

stockent dans le tableau ptr. Cette fonction retourne le nombre 

d’éléments effectivement lus (peut être différent de n). En cas 

d’erreur par rapport à ce qui est attendu, le programmeur utilisera les 

fonctions de gestion d’erreur sur flots 

size t fwrite (void *ptr, size t size, size t n, FILE *stream); 

↩→ Idem à la fonction précédente mais dans l’autre sens : elle écrit 

les éléments sur le flot. Retourne aussi le nombre d’éléments traités


Positionnement dans les fichiers 

int fseek (FILE *stream, long offset, int origin); 

↩→ Déplacement à une position donnée dans un flot. Le déplacement 

dépend de type de fichier : 

binaire : La nouvelle position est à offset octets de l’origine 

origin, qui est soit le début du fichier (SEEK SET), soit la fin du 

fichier (SEEK END), soit la position courante (SEEK CUR). 

texte : offset faudra soit 0, soit une valeur retournée par 

ftell, avec origin==SEEK SET 

Une erreur correspond à une valeur de retour non nulle 

int ftell (FILE *stream); 

↩→ Retourne la position courante sur le flot donné, ou bien -1 en cas 

d’erreur


void rewind (FILE *stream); 

↩→ L’indicateur de position revient au début du fichier, et annule les 

erreurs éventuellement survenues sur le flot 

int fgetpos (FILE *stream, fpos t *ptr); 

↩→ Place dans *ptr la position courante. Retourne une valeur non 

nulle en cas d’erreur 

int fsetpos (FILE *stream, fpos t *ptr); 

↩→ Positionne le flot à la position mémorisée dans *ptr. Retourne 

une valeur non nulle en cas d’erreur


Certaines fonctions de la bibliothèque standard affectent, dans la 

structure FILE, un indicateur pour signaler une erreur et un autre 

pour signaler que la fin de fichier a été atteinte 

Ces indicateurs peuvent être gérés via les fonctions suivantes 

void clearerr (FILE *stream); 

↩→ Remet à zéro les erreurs et fin de fichier sur un flot donné 

int feof (FILE *stream); 

↩→ Retourne une valeur non nulle si l’indicateur de fin de fichier est à 

vrai 

int ferror (FILE *stream); 

↩→ Retourne une valeur non nulle si l’indicateur d’erreur est à vrai 

void perror (const char *msg); 

↩→ Imprime un message d’erreur précédé du contenu de msg, en 

fonction de la valeur de la variable globale errno. Cette dernière et 

son prototype sont définis dans


102 

Tests sur les caractères : 

Pour chacune des fonctions suivantes, le caractère c est un int 

(et non pas char, notamment parce que EOF==-1). Elles retournent 

une valeur != 0 si l’argument c remplit la condition indiquée, 0 sinon 

1 int isalnum(int c); /* == isalpha(c) || isdigit(c) */ 

2 int isalpha(int c); /* Une lettre qqs la casse */ 

3 int iscntrl(int c); /* Caractere de controle */ 

4 int isdigit(int c); /* Chiffre decimal */ 

5 int isgraph(int c); /* Caractere imprimable - espace */ 

6 int islower(int c); /* Lettre minuscule */ 

7 int isprint(int c); /* Caractere imprimable */ 

8 int ispunct(int c); /* Caractere - {lettres, espaces, chiffres} */ 

9 int isspace(int c); /* Espace au sens large (espace, saut de page, fin de ligne, 

10 retour chariot, tabulation, tabulation verticale) */ 

11 int isupper(int c); /* Lettre majuscule */ 

12 int isxdigit(int c); /* Chiffre hexadecimal */ 

Deux fonctions supplémentaires retournent la lettre c dans la 

casse correspondante (ou c si c n’est pas de la casse inverse) 

14 int toupper(int c); /* Retourne une lettre majuscule */ 

15 int tolower(int c); /* Retourne une lettre minuscule */


103 

Manipulation de chaînes de caractères : 

Cette librairie regroupe deux sortes de fonctions : 

Celles manipulant des chaînes de caractères, i.e. des tableaux 

de char contenant un ’\0’ ; Leur nom commence par str 

Celles manipulant des tableaux d’octets de longueurs 

quelconques ; Leur nom débute par mem 

Dans la suite, les paramètres des fonctions listées seront : 

s et t de type char * 

cs et ct de type const char * 

n de type size t 

c de type int


char *strcpy (s, ct) 

char *strncpy (s, ct, n) 

char *strcat (s, ct) 

char *strncat (s, ct, n) 

int strcmp (cs, ct) 

int strncmp (cs, ct, n) 

char *strchr (cs, c) 

char *strrchr (cs, c) 

char *strdup (cs) 

size t strlen (cs) 

char *strerror (n) 

copie ct dans s, retourne s 

copie n caractères de ct dans s, en 

complétant éventuellement par des 0 

et retourne s 

concatène la chaîne ct en fin de s 

et retourne s 

idem pour au plus n caractères de ct 

compare les chaînes cs et ct selon l’ordre 

lexicographique et retourne ct et 0 si identiques 

idem en comparant au plus les n premiers 

caractères 

retourne l’adresse de la première occurrence 

de c dans cs, ou NULL le cas échéant 

idem, mais pour la dernière occurrence 

allocation, puis duplication de cs 

(⇒ faire un free() après) 

retourne la longueur de cs 

retourne la chaîne associée à l’erreur n


Les fonctions suivantes permettent des traitements efficaces sur 

les tableaux d’octets (gèrent au mieux les défauts de page) 

RMQ : à part pour memmove, leur comportement est indéterminé en cas 

de chevauchement des tableaux d’octets (en mémoire) . . . 

Dans la suite, les paramètres des fonctions listées seront : 

s et t de type void * 

n de type size t 

cs et ct de type const void * c de type int 

void *memcpy (s, ct, n) 

void *memmove (s, ct, n) 

void *memcmp (cs, ct, n) 

void *memchr (cs, c, n) 

void *memset (s, c, n) 

copie de n octets de ct vers s ; retourne 

s 

”déplace” n octets de ct vers s qui peuvent 

se chevaucher ; retourne s 

compare les n premiers octets de cs et 

ct (comme strncmp) 

retourne l’adresse de la première occurrence 

de c dans cs, ou NULL le cas 

échéant 

remplie et retourne s avec n fois c


104 

Fonctions mathématiques : 

La librairie mathématiques C fournie un ensemble de fonctions 

dont le calcul n’est pas trivial 

Définies dans libm.o ou libm.lib ⇒ option -lm 

Dans la suite : 

les paramètres x et y sont de type double 

le paramètre n est de type int 

toutes les fonctions retournent un double 

sin (x) 

sinus de x 

cos (x) 

cosinus de x 

tan (x) 

tangente de x 

asin (x) arc sinus de x, dans [−π/2, π/2], pour x ∈ [−1, 1] 

acos (x) arc cosinus de x, dans [0, π], pour x ∈ [−1, 1] 

atan (x) 

arc tangente de x, dans [−π/2, π/2] 

atan2 (x, y) arc tangente de x/y, dans [−π, π]


sinh (x) 

sinus hyperbolique de x 

cosh (x) 

cosinus hyperbolique de x 

tanh (x) 

tangente hyperbolique de x 

exp (x) exponentielle de x (i.e. e x ) 

log (x) logarithme népérien, pour x > 0 

log10 (x) logarithme à base 10, pour x > 0 

élévation de x à la puissance y (i.e. x 

pow (x, y) 

) Erreur de 

domaine si (x==0 && y


frexp (x, int *exp) 

modf (x, double *ip) 

fmod (x, y) 

sépare x en une fraction normalisée dans 

[−1/2, 1[ qui est retournée, et une puissance 

de 2 placée dans *exp. Si x==0, 

les valeurs retournées sont nulles 

sépare x en ses parties entières (dans 

*ip) et fractionnaire (retournée) de même 

signe que x 

reste de x/y de même signe que x. Comportement 

indéterminé si y==0 

Certaines erreurs peuvent survenir : les macros relatives aux réels sont 

écrites dans . La variable globale errno reçoit EDOM ou 

ERANGE en cas d’erreur de domaine ou d’intervalle ; lorsqu’un résultat est 

trop grand pour être représenté par un double, alors on utilise HUGE VAL 

avec le signe nécessaire, et errno reçoit ERANGE. Inversement, si le 

résultat est trop petit, 0 est retourné, et peut-être que errno reçoit ERANGE 

RMQ : ne pas vérifier les erreurs c’est aller au devant de bugs difficiles à 

détecter


105 

Fonctions utilitaires : 

Dans ce module, on trouve les fonctions de conversions, 

d’allocation mémoire et autres outils très utiles ! 

Conversions chaînes ↦−→ nombres 

double atof (const char *s) ; 

int atoi (const char *s) ; 

long atol (const char *s) ; 

↩→ Ces trois fonctions convertissent une chaîne de caractères 

RMQ : Pour s="23trucs", les résultats seront 23. . .


On trouve aussi dans ce module la gestion de la mémoire 

dynamique 

void *calloc(size t nmemb, size t size); 

void *malloc(size t size); 

void *realloc(void *ptr, size t size); 

void free(void *ptr); 

RMQ : Rappelons que les 3 premières retournent NULL en cas d’erreur et 

donc qu’il importe de tester cette valeur pour gérer les erreurs 

On trouve aussi les fonctions permettant d’interrompre l’exécution 

du programme : 

void abort(void); 

void exit(int status); 

int atexit(void (*function)(void)); 

RMQ : La dernière permet d’enregistrer une fonction qui sera appelée 

lors de la sortie normale d’un programme


D’autres fonctions permettent de d’interagir avec le système 

int system(const char *commande); 

char *getenv(const char *name); 

↩→ system() passe la chaîne s à l’environnement d’exécution pour que 

celui-ci l’exécute (comme une ligne de commande). Retourne -1 en cas 

d’erreur, le code de retour de la commande en cas de succès 

↩→ getenv() recherche name dans la liste des variables d’environnement, 

et renvoie un pointeur sur la chaîne correspondante 

Des fonctions de tri sont également à disposition 

void qsort(void *base, size t n, size t size, 

int(*cmp)(const void *, const void *)); 

void *bsearch(const void *key, const void *base, size t n, 

size t size, int (*cmp)(const void *, const void *)); 

→ Elles agissent sur un tableau base d’objets de taille size octets et en 

nombre n. Le tri et la recherche se font via une fonction cmp capable de 

comparer 2 éléments du tableau (e.g. strcmp()) 

→ La recherche utilise sur un objet key, qui est l’adresse de l’élément 

recherché dans le tableau et retourne NULL si elle ne trouve pas


Les fonctions de génération de nombres pseudo-aléatoires 

void srand(unsigned int seed); 

int rand(void); 

La fonction srand() utilise son argument comme ”graine” pour générer 

une nouvelle séquence de nombres pseudo-aléatoires, qui seront ensuite 

fournis par rand(). Ces séquences sont reproductibles en appelant 

srand() avec la même valeur de graine. 

Il est 

recommandé 

de les utiliser 

d’une manière 

particulière 

19 /* AUTHOR: Jean-Marc Bourguet, March 2006, www.bourguet.org */ 

20 int hasard_alea (int n) { 

21 int partSize = 1 + (n == RAND_MAX ? 0 : (RAND_MAX - n) / (n + 1)); 

22 int draw, maxUsefull = partSize * n + (partSize-1); 

23 do { 

24 draw = rand(); 

25 } while (draw > maxUsefull); 

26 return draw / partSize; 

27 } 

28 

29 void hasard_initialiser_graine () { 

30 srand (time (NULL)) ; 

31 } 

32 

33 int hasard_generer_nombre (int min, int max) { 

34 return min + hasard_alea (max-min) ; 

35 }


106 

La date et l’heure : 

Ce module permet, depuis un programme, de récupérer la date et 

l’heure auprès du système d’exploitation 

Dans la suite, clock t et time t sont des entiers représentant 

des instants, et la structure tm est la suivante : 

3 struct tm { 

4 int tm_sec; /* secondes [0-60] */ 

5 int tm_min; /* minutes [0-59] */ 

6 int tm_hour; /* heures [0-23] */ 

7 int tm_mday; /* jour du mois [1-31] */ 

8 int tm_mon; /* mois [0-11] */ 

9 int tm_year; /* annee - 1900 */ 

10 int tm_wday; /* jour de semaine [0-6] */ 

11 int tm_yday; /* jours depuis 1er janvier [0-365] */ 

12 int tm_isdst; /* drapeau heure d’ete [-1/0/1] */ 

13 }; 

Le champ tm isdst est positif en heure d’été, nul en hivers, et négatif si 

cette information est inconnue


clock t clock(void); 

↩→ Retourne le temps CPU, en unités d’horloge, depuis le début de 

l’exécution du programme, ou -1 s’il est impossible de le savoir. Pour 

obtenir une durée en secondes, diviser par CLOCKS PER SEC ou CLK TCK 

time t time(time t *tp); 

↩→ Retourne et initialise tp avec l’heure calendaire ou -1 si non disponible 

(tp peut être NULL). (nombre de secondes écoulées depuis le 1er janvier 

1970 sous Unix) 

double difftime(time t t1, time t t0); 

↩→ Renvoie le nombre de secondes écoulées entre les instants t1 et t0 au 

format double 

time t mktime(struct tm *tm); 

↩→ Convertit une heure locale en heure calendaire. Retourne -1 si 

problème. . .


char *asctime(const struct tm *tm); 

↩→ Convertit une heure en une chaîne de caractères. Cette dernière est un 

tableau statique de la fonction (donc écrasement !) 

struct tm *localtime(const time t *tp); 

↩→ Convertit l’heure calendaire *tp en heure locale 

char *ctime(const time t *timep); 

↩→ Convertit une heure calendaire en chaîne de caractères (⇒ 

asctime(localtime(tp))) 

struct tm *gmtime(const time t *timep); 

↩→ Convertit *tp en Temps Universel. Retourne NULL si ce dernier n’est 

pas disponible


size t strftime(char *s, size t smax, 

const char *fmt, const struct tm *tm); 

↩→ Convertit un temps *tm en une chaîne s selon un format défini par la 

chaîne fmt. Retourne le nombre de caractères (moins le ’\0’) produits, ou 

0 si ce nombre aurait été supérieur à smax. 

→ Les caractères de la chaîne fmt sont traités à la manière des fonctions 

printf()et autres. Les sélecteurs sont : 

%a abréviation du jour de la semaine %M minutes 

%A nom complet du jour de la semaine %p équivalence locale de AM ou PM 

%b abréviation du mois %S secondes (00-60) 

%B nom complet du mois %U numéro de la semaine dans l’année, 

%c représentation locale commence au 1 er dimanche (00-53) 

%d jour du mois (01-31) %W numéro de la semaine dans l’année, 

%H heure sur 24 (0-23) commence au 1 er lundi (00-53) 

%I heure sur 12 (1-12) %w numéro du jour de la semaine (0-6) 

%j numéro du jour de l’année (001-366) %x représentation locale de la date 

%m numéro du jour du mois (01-12) %X idem pour l’heure 

%z nom du fuseau horaire %y année dans le siècle 

%% % %Y année

Plan 254 



3 Opérateurs 



6 Fonctions 

7 Pointeurs 

8 Structures 




11 GÉNIE LOGICIEL ET C Introduction 255 

Définition : art de spécifier, concevoir, réaliser et faire évoluer, avec 

des moyens et dans des délais raisonnables, des programmes, des 

documentations et des procédures de qualité en vue d’utiliser un 

ordinateur pour résoudre certains problèmes 

111 

Du génie logiciel à la programmation 

Objectifs du génie logiciel : structurer et ”formaliser” les différentes 

étapes de conception du logiciel pour obtenir des logiciels plus 

fiables, réutilisables et performants 

Avant la programmation : 

→ cahier des charges, spécifications globales, spécifications 

détaillées 

Après la programmation : 

→ intégration, tests, maintenance 

Pendant la programmation : 

→ encapsulation, généricité, modularité

11 GÉNIE LOGICIEL ET C Méthode 256 

Une méthode de conception : 

concevoir un programme comme une armée mexicaine 

Un minimum de soldats : ils font tout le travail ! 

→ soldat = fonction élémentaire qui accède directement aux 

structures de données 

Un maximum de colonels : ils font travailler les soldats. . . 

→ colonel = fonction qui utilise exclusivement des fonctions 

élémentaires en les combinant 

Un général : il organise l’intervention des colonels 

→ général = fonction principale qui appelle les fonctions, 

élémentaires ou non

11 GÉNIE LOGICIEL ET C Caractéristiques 257 

112 

Caractéristiques d’un programme 

Encapsulation 

→ les colonels ne connaissent pas les outils des soldats 

→ ils organisent l’intervention des soldats indépendamment de 

leurs outils 

Généricité 

→ certains soldats et colonels sont remplaçables, sans que le 

travail du reste de l’armée ne soit modifié 

Modularité 

→ On structure l’armée mexicaine en plusieurs garnisons 

→ Chaque garnison distingue elle-même les soldats, les 

colonels, et sa propre description

11 GÉNIE LOGICIEL ET C Caractéristiques 258 

En pratique cela revient à : 

Encapsulation (”masquage” des données) 

→ les fonctions de haut niveau ne connaissent pas les structures 

de données 

→ leur description est indépendante de ces structures 

Généricité 

→ on peut définir des données qui en manipulent d’autres, sans 

que ces dernières ne soient connues 

Modularité 

→ on structure le programme en modules (paquetages) 

→ chaque module distingue lui-même les fonctions 

élémentaires, les fonctions et leur description (fichier d’interface, 

d’implantation, public et privé. . .)

Fin 259 

Ce que nous n’avons pas abordé, ou alors que faiblement, dans ce 

cours de 8h (non exhaustif) : 

Les pointeurs ; Les pointeurs de fonction ; 

Les champs de bits ; Les unions ; 

Les macro fonctions ; La compilation conditionnelle ; 

Les structures auto-référentielles (liste, pile, file, arbre, graphe) ; 

Les mots clés continue et goto (proscrits) ; 

Les E/S binaires (open(), read(), write(), close()) ; 

. . . 

↩→ Aller plus loin : 

”Le langage C” Henri Garreta 

http://c.developpez.com/cours/poly-c/ 

”Le langage C” B. Kernighan & D. Ritchie (éditions Dunod)

Table des matières – I 260 

1 Introduction 17 

2 Types de base 58 

1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 

2 Variables entières (char et int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 

3 Variables réelles (float et double) . . . . . . . . . . . . . . . . . . . . . . . . . . 63 

4 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 

5 Les caractères et la table ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 

6 Les variables constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 

7 Constantes classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 

8 Constantes énumérées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 

9 Conversions de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 

10 Exemples d’erreurs classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 

3 Opérateurs 87 

1 L’opérateur d’affectation = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 

2 Les opérateurs arithmétiques + − ∗ / % . . . . . . . . . . . . . . . . . . . 91 

3 Incrémentation et décrémentation ++ et −− . . . . . . . . . . . . . . . . . . 94

Table des matières – II 261 

4 Les opérateurs logiques == = < > != && || . . . . . . . 95 

5 Traitement des bits & | > . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 

6 Opérateurs et expressions d’affectations += −= /= ∗= %= 

102 

7 Priorité et associativité des opérateurs . . . . . . . . . . . . . . . . . . . . . . . 103 

4 Entrées/Sorties 105 

1 Écriture d’une chaîne simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 

2 Écriture de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .111 

3 Nombre minimum de caractères produits . . . . . . . . . . . . . . . . . . . . 114 

4 Table des formats possibles pour printf() . . . . . . . . . . . . . . . . . 116 

5 Un flux de sortie distinct pour les erreurs : stderr . . . . . . . . . . .119 

6 Les redirections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 

7 Comportement (asynchrone) de scanf() . . . . . . . . . . . . . . . . . . . 123 

8 Utilisation de scanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 

9 Table des formats possibles pour scanf() . . . . . . . . . . . . . . . . . . 127 

10 Ouvrir un descripteur de fichier avec fopen() . . . . . . . . . . . . . . . 131 

11 Écrire dans un fichier avec fprintf() . . . . . . . . . . . . . . . . . . . . . . 137

Table des matières – III 262 

12 Lire dans un fichier avec fscanf() . . . . . . . . . . . . . . . . . . . . . . . . . 139 

13 Accès fichiers caractère par caractère fgetc() et fputc() 141 

5 Structures de Contrôle & Boucles 143 

1 La structure conditionnelle classique if . . . . . . . . . . . . . . . . . . . . . 145 

2 Le contrôle par else if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 

3 L’opérateur de conditionnelle ? : . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

4 La structure de contrôle switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 

5 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 

6 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 

7 La boucle do...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .168 

6 Fonctions 170 

1 La fonction principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

2 Définition d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 

3 Passage des paramètres par valeur . . . . . . . . . . . . . . . . . . . . . . . . . .181 

4 Retour sur les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .183 

5 Variable locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184

Table des matières – IV 263 

6 Variable globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 

7 Variable statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187 

8 Surcharge des noms de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . .188 

9 Cas des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 

10 Récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 

7 Pointeurs 195 

1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 

2 Passage des paramètres par adresse . . . . . . . . . . . . . . . . . . . . . . . .200 

3 Mémoire dynamique avec malloc() et free() . . . . . . . . . . . . .202 

4 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 

8 Structures 207 

1 Principes généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 

2 Fonctions et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 

3 Tableaux et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 

4 Les structures auto-référencielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 

9 Le préprocesseur 220

Table des matières – V 264 

1 Les macro-constantes avec #define . . . . . . . . . . . . . . . . . . . . . . . .222 

2 Les paquetages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 

10 Bibliothèque standard 231 

1 Les entrées sorties : . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 

2 Tests sur les caractères : . . . . . . . . . . . . . . . . . . . . . . .239 

3 Manipulation de chaînes de caractères : . . . . . . 240 

4 Fonctions mathématiques : . . . . . . . . . . . . . . . . . . . . . . 243 

5 Fonctions utilitaires : . . . . . . . . . . . . . . . . . . . . . . . . . . 246 

6 La date et l’heure : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 

11 Génie logiciel et C 254 

1 Du génie logiciel à la programmation . . . . . . . . . . . . . . . . . . . . . . . . .255 

2 Caractéristiques d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257




Pour écran 


Par chapitre 




Archive zip 

Exercices 






Manuels

cours entier

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?