Programmation en Langage C

Alexandre Meslé

12 mars 2019
Table des matières

1 Notes de cours 2
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Définitions et terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Hello World ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Structure d’un programme C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.4 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.5 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.6 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.7 Caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.8 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.2 Les opérateurs unaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.3 Les opérateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3.4 Formes contractées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.5 Opérations hétérogènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.6 Les priorités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.4 Traitements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.1 Si ... Alors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.4.3 Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.4 Les priorités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.4.5 Préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5.1 Définitions et terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5.3 do ... while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.5.4 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.5.5 Accolades superflues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.6.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.6.2 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.6.3 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.6.4 Accès aux éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6.5 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.7 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.7.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.7.2 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

1
 1.7.3 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.7.4 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.7.5 Accès aux éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.7.6 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.7.7 Saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.7.8 Problèmes liés à la saisie bufferisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7.9 La bibliothèque string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7.10 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.8 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.8.1 Les procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.8.2 Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1.8.3 Passage de paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.8.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.8.5 Passages de paramètre par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.9 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.9.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.9.2 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.9.3 Accès aux champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.9.4 Typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.9.5 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.9.6 Structures et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.10 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.10.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
1.10.3 Allocation dynamique de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.10.4 Passage de paramètres par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.10.5 Pointeurs sur fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.11 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1.11.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1.11.2 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1.11.3 Lecture et écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
1.12 Listes Chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.12.1 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.12.2 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.12.3 Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.12.4 Le chaînage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
1.12.5 Utilisation de malloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.12.6 Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
1.12.7 Listes doublement chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
1.13 Conseils techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
1.13.1 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
1.13.2 Les règles d’or . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
1.13.3 Débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.13.4 Durée de vie du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.13.5 Exemple : le carnet de contacts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

2 Exercices 82
2.1 Variables et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.1.1 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.1.2 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.1.3 Caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
2.1.4 Opérations sur les bits (difficiles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
2.1.5 Morceaux choisis (difficiles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
2.2 Traitements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.2.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

2
 2.2.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.2.3 L’échiquier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.2.4 Heures et dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.2.5 Intervalles et rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
2.2.6 Préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
2.2.7 Nombres et lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
2.3.1 Compréhension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
2.3.2 Utilisation de toutes les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.3.3 Choix de la boucle la plus appropriée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.3.4 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.3.5 Extension de la calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
2.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.4.1 Exercices de compréhension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.4.2 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.4.3 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.4.4 Recherche séquentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.4.5 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.5 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.5.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.5.2 Les fonctions de string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.5.3 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
2.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.6.1 Géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.6.2 Arithmétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
2.6.3 Passage de tableaux en paramètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.6.4 Décomposition en facteurs premiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.6.5 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.6.6 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.6.7 Programmation d’un Pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
2.6.8 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
2.7 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
2.7.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
2.7.2 Heures de la journée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
2.7.3 Répertoire téléphonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.8.1 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.8.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.8.3 Exercices sans sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.8.4 Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.8.5 Pointeurs et pointeurs de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.8.6 Passages de paramètres par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
2.8.7 Les pointeurs sans étoile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.8.8 Tableau de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.8.9 Triangle de Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.8.10 Pointeurs et récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.8.11 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.9.1 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.9.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.9.3 Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.9.4 Lecture et écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.9.5 Enigma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.10 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

3
2.11 Initiation à la récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2.11.1 Sous-programmes récursifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2.11.2 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2.12 Listes Chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
2.12.1 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
2.12.2 Maniement du chaînage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
2.12.3 Opérations sur les listes chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
2.12.4 Listes doublement chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
2.12.5 Fonctions récursives et listes chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

4
Chapitre 1

Notes de cours

1.1 Introduction
1.1.1 Définitions et terminologie
Un programme exécutable est une suite d’instructions exécutée par le processeur. Ces instructions sont très difficile
à comprendre, si par exemple, vous ouvrez avec un éditeur de texte (notepad, emacs, etc) un fichier exécutable, vous
verrez s’afficher un charabia incompréhensible :
00000000
0000001f
0000003e
0000005d
0000007c
0000009b
000000ba
000000d9
000000f8
00000117
00000136
00000155
00000174
00000193
000001b2
000001d1
000001f0
0000020f
0000022e
0000024d
0000026c
0000028b
000002aa
000002c9
000002e8
00000307
...
Il n’est pas envisageable de créer des programmes en écrivant des suites de chiffres et de lettres. Nous allons donc
utiliser des langages de programmation pour ce faire.

Un programme C est un ensemble d’instructions qui se saisit dans un fichier .c à l’aide d’un éditeur (ex. : No-
tepad), ce type de fichier s’appelle une source. Les instructions qui y sont écrites s’appellent du code ou encore le

5
code source. Un compilateur est un logiciel qui lit le code source et le convertit en un code exécutable, c’est-à-dire
un ensemble d’instructions compréhensible par le processeur. La compilation d’une source se fait en deux étapes : la
compilation proprement dite et le linkage. On utilise en général le terme compilation en englobant les deux étapes
précédemment citées.
— La compilation à proprement parler produit un fichier objet, dont l’extension est .obj.
— Les sources peuvent être réparties dans plusieurs fichiers, ceux-ci doivent tous être compilés séparément. Ensuite,
le linkage des différents fichiers objets est assemblage produisant un exécutable .exe.
Certains environnement de développement servent d’éditeur, et prennent en charge la compilation et le linkage
(eclipse, dev-C++).

1.1.2 Hello World !

Allez sur [Link] cliquez
sur télécharger. Installez Dev-C++. Ouvrez un nouveau fichier source. Copiez-collez le code ci-dessous dans l’édi-
teur :
#include<s t d i o . h>

i n t main ( )
{
printf ( " Hello World !\ n" ) ;
return 0 ;
}

Sauvegardez ce fichier sous le nom helloWorld.c. Dans le menu Exécuter, cliquez sur Compiler. Remarquez que la
compilation a produit un fichier [Link]. Vous avez deux façons de l’exécuter :
— double-cliquez directement sur [Link]
— Dans le menu Exécuter, cliquez sur exécuter.

1.1.3 Structure d’un programme C

Importation des bibliothèques

#include<s t d i o . h>

Selon ce que l’on souhaite faire dans notre programme, on peut avoir besoin de différentes fonctions. Celles-ci sont
disponibles dans des bibliothèques. Par exemple, stdio.h propose des fonctions de saisie et d’affichage.

Corps du programme

i n t main ( )
{
printf ( " Hello world !" ) ;
getch ( ) ;
return 0 ;
}

On place dans les accolades du main les instructions que l’on souhaite voir s’exécuter :
i n t main ( )
{
<instructionsAExecuter>
return 0 ;
}

Remarquez que chaque ligne se termine par un points-virgule. Pour afficher une variable de type aphanumérique
en C, on utilise printf(<valeur àafficher>);. Les littéraux de type alphanumériques en C s’écrivent entre doubles
quotes.

6
1.1.4 Commentaires
Un commentaire est une séquence de caractères ignorée par le compilateur, on s’en sert pour expliquer des portions
de code. Alors ayez une pensée pour les pauvres programmeurs qui vont reprendre votre code après vous, le pauvre
correcteur qui va essayer de comprendre votre pensée profonde, ou bien plus simplement à vous-même au bout de six
mois, quand vous aurez complètement oublié ce que vous aviez dans la tête en codant. On délimite un commentaire
par /∗ et ∗/. Par exemple,
i n t main ( )
{
/∗
Ceci e s t un commentaire :
L ’ i n s t r u c t i o n c i −d e s s o u s a f f i c h e ’ ’ H e l l o morld ! ’ ’
Ces p h r a s e s s o n t i g n o r é e s par l e c o m p i l a t e u r .
∗/
printf ( " Hello world !\ n" ) ;
return 0 ;
}

7
1.2 Variables
Une variable est un emplacement de la mémoire dans lequel est stockée une valeur. Chaque variable porte une nom et
c’est ce nom qui sert à identifier l’emplacement de la mémoire représenté par cette variable. Pour utiliser une variable,
la première étape est la déclaration.

1.2.1 Déclaration
Déclarer une variable, c’est prévenir le compilateur qu’un nom va être utilisé pour désigner un emplacement de
la mémoire. En C, on déclare les variables juste après l’accolade suivant main() (pour le moment). On place les
instructions à exécuter à la suite de la déclaration de variables.
main ( )
{
<declaration de variables>
<instructions a executer>
}

Nous ne travaillerons pour le moment que sur les variables de type numérique entier. Le type qui y correspond, en
C, est int. On déclare les variables entières de la manière suivante :
i n t <var_1 >, <var_2 >, . . . , <var_n >;

Cette instruction déclare les variables var_1, var_2, ..., var_n de type entier. Par exemple,
#include<s t d i o . h>

i n t main ( )
{
i n t variable1 , variable2 ;
i n t autrevariable1 , autrevariable2 ;
return 0 ;
}

On appelle bloc le contenu des accolades du main.

1.2.2 Affectation
Si on souhaite affecter à la variable v une valeur, on utilise l’opérateur =. Par exemple,
i n t main ( )
{
int v ;
v = 5;
return 0 ;
}

Ce programme déclare une variable de type entier que l’on appelle v, puis lui affecte la valeur 5. Comme vous venez
de le voir, il est possible d’écrire directement dans le code une valeur que l’on donne à une variable. Notez l’abscence
de include, ce programme n’effectue aucune entrée-sortie, il n’est donc pas nécessaire d’importer les bibliothèques
d’entrées/sorties.

Les opérations arihmétiques disponibles sont l’addition (+), la soustraction (−), la multiplication (∗), la division
entière dans l’ensemble des entiers relatifs (quotient : /, reste : %).
i n t main ( )
{
int v , w , z ;
v = 5;
w = v + 1;

8
 z = v + w / 2;
v = z % 3;
v = v ∗ 2;
return 0 ;
}

1.2.3 Saisie
Traduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour récupérer la saisie d’un
utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante :
scanf ( "%d" , &<variable >) ;

scanf suspend l’exécution du programme jusqu’à ce que l’utilisateur ait saisi une valeur et pressé la touche return.
La valeur saisie est alors affetée à la variable <variable>. N’oubliez surtout pas le &, sinon des choses absurdes
pourraient se produire !

1.2.4 Affichage
Traduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher la valeur d’une
variable.
printf ( "%d" , <variable >) ;

Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner par l’ap-
parente complexité de cette instruction !). Nous avons étendu, en algorithmique, l’instruction Afficher en intercalant
des valeurs de variables entre les messages affichés. Il est possible de faire de même en C :
printf ( " la valeur de la variable v est %d" , v ) ;

Cette instruction substitue à %d la valeur de la variable v. Il est possible de l’étendre à volonté :

printf ( " les valeurs des variables x , y et z sont %d , %d et %d" , x , y , z ) ;

Cette instruction substitue à chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme suivant
#include<s t d i o . h>

i n t main ( )
{
int a , b , c ;
a = 1;
b = 2;
c = 3
printf ( " La valeur de a est %d , celle de b est %d , et celle de "
"c est %d." , a , b , c ) ;
return 0 ;
}

affiche

La valeur de a est 1, celle de b est 2, et celle de c est 3.

1.2.5 Entiers
Trois types de base servent à représenter les entiers :
nom taille (t) nombre de valeurs (28t ) chaîne de format
short 1 octet 28 valeurs %hd
int 2 octets 216 valeurs %d
long 4 octets 232 valeurs %ld

9
Entiers non signés
Par défaut, les entiers permettent de stocker des valeurs de signe quelconque. Si on préfixe un type entier par
unsigned, on le restreint à des valeurs uniquement positives. Dans ce cas, on a
nom taille (t) nombre de valeurs (28t ) valeur min valeur max format
unsigned short 1 octet 28 valeurs 0 28 − 1 %hu
unsigned int 2 octets 216 valeurs 0 216 − 1 %u
unsigned long 4 octets 232 valeurs 0 232 − 1 %lu
La plage de valeur d’un unsigned short, encodée en binaire, est

{0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111}

Entiers signés
Si par contre les données sont signées, on a comme plage de valeurs
nom taille (t) nombre de valeurs (28t ) plus petite valeur plus grande valeur
short 1 octet 28 valeurs −27 27 − 1
16 15
int 2 octets 2 valeurs −2 215 − 1
32 31
long 4 octets 2 valeurs −2 231 − 1
La plage de valeur d’un short, encodée en binaire, est aussi

{0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 1111 1110, 1111 1111}
Même si les codages sont les mêmes, la signification ne l’est pas, les nombres entiers positifs sont codés sur l’inter-
valle :

{0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 0111 1100, 0111 1101, 0111 1110, 0111 1111}
Et les nombres négatifs sur l’intervalle

{1000 0000, 1000 0001, 1000 0010, 1000 0011, . . . , 1111 1100, 1111 1101, 1111 1110, 1111 1111}
Les nombres négatifs sont disposés du plus grand jusqu’au plus petit, l’intervalle précédent code les valeurs :

{−27 , −(27 − 1), −(27 − 2), −(27 − 3), . . . , −4, −3, −2, −1}
Les opérations arithmétiques sont exécutées assez bêtement, si vous calculez 0111 1111 + 0000 0001, ce qui cor-
respond à (27 − 1) + 1, le résultat mathématique est 27 , ce qui se code 1000 0000, ce qui est le codage de −27 . Soyez
donc attentifs, en cas de dépassement de capacité d’un nombre entier, vous vous retrouverez avec des nombres qui ne
veulent rien dire. Si vous souhaitez faire des calculs sur des réels, un type flottant sera davantage adapté.

1.2.6 Flottants
Les flottants servent à représenter les réels. Leur nom vient du fait qu’on les représente de façon scientifique : un
nombre décimal (à virgule) muni d’un exposant (un décalage de la virgule). Trois types de base servent à représenter
les flottants :
nom taille chaîne de format
float 4 octet %f
double 8 octets %f
long double 10 octets %Lf
Il est conventionel d’écrire des littéraux flottants avec un point, par exemple l’approximation à 10−2 près de π
s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le décimal 1 000 s’écrit 1e3, à savoir
1.103 .Nous nous limiterons à la description du type float, les autres types obéissent à des règles similaires.

10
Représentation en mémoire d’un float
Le codage d’un nombre de type float (32 bits) est découpé en trois parties :
partie taille
le bit de signe 1 bit
l’exposant 8 bits
la mantisse 23 bits
Le nombre est positif si le bit de signe est à 0, négatif si le bit de signe est à 1. La mantisse et l’exposant sont codés en
m
binaire, la valeur absolue d’un flottant de mantisse m et d’exposant e est 23 .2e . Le plus grand entier qu’il est possible
2
(223 − 1) 7 (223 − 1) (27 )
de coder sur 23 octets est , le plus grand exposant est 2 , donc le plus grand flottant est .2 ,
223 223
23
(2 − 1) (27 )
donc le plus petit est − .2 .
223

1.2.7 Caractères
Un char sert à représenter le code ASCII d’un caractère, il est donc codé sur 1 octet. Il est possible d’affecter à une
telle variable toute valeur du code ASCII entourée de simples quotes. Par exemple, l’affectation suivante place dans a
le code ASCII du caractère ’B’.
char a ;
a = ’B ’ ;

De la même façon que l’on code des nombres entiers sur 1 octet avec un short, un char contient avant tout un
nombre codé sur 1 octet. Pour afficher le caractère corrspondant au code ASCII stocké dans un char, on utilise la chaîne
de format %c, et pour afficher le code ASCII lui-même on utilise la chaîne de format %d. Si on souhaite manipuler des
char comme des nombres, le type unsigned char permet de coder des valeurs positives sur 1 octet, alors que char code
aussi bien des nombres positifs que négatifs. Par conséquent, les caractères de code ASCII 255 et 128 correspondent
aux unsigned char de valeurs 255 et 128 et aux char de valeurs −1 et −128.

1.2.8 Constantes
Une constante est une valeur portant un nom, contrairement aux variables, elles ne sont pas modifiables. Les
constantes en C sont non typées, on les définit dans l’entête de la source, juste en dessous des #include. La syntaxe
est #define <NOM_CONSTANTE> <valeurConstante>, par exemple #define N 25 définit une constante N qui a la
valeur 25. Au début de la compilation, un programme appelé préprocesseur effectue un rechercher/remplacer et
substitue à toutes les occurences de <NOM_CONSTANTE> la valeur <valeurConstante>. Faites donc très attention au fait
que dans l’exemple présent, le préprocesseur va remplacer tous les N par des 25. Donc si une variable s’appelle N , le
préprocesseur va le remplacer par un 25 ! Si par exemple vous écrivez
#include<s t d i o . h>

#define N 25

i n t main ( )
{
int N ;
N = 12;
printf ( "N = %d" , N ) ;
return 0 ;
}

Le préprocesseur va le transformer en
#include<s t d i o . h>

#define N 25

11
i n t main ( )
{
int 2 5 ;
25 = 1 2 ;
printf ( "N = %d" , 2 5 ) ;
return 0 ;
}

Vous remarquez que les seules exceptions sont les valeurs délimitées par des ".

12
1.3 Opérateurs
1.3.1 Généralités
Opérandes et arité
Lorsque vous effectuez une opération, par exemple 3 + 4, le + est un opérateur, 3 et 4 sont des opérandes. Si l’opérateur
s’applique à 2 opérandes, on dit qu’il s’agit d’un opérateur binaire, ou bien d’arité 2. Un opérateur d’arité 1, dit aussi
unaire, s’applique à un seul opérande, par exemple −x, le x est l’opérande et le − unaire est l’opérateur qui, appliqué
à x, nous donne l’opposé de celui-ci, c’est-à-dire le nombre qu’il faut additionner à x pour obtenir 0. Il ne faut pas le
confondre avec le − binaire, qui appliqué à x et y, additionne à x l’opposé de y.
En C, les opérateurs sont unaires ou binaires, et il existe un seul opérateur ternaire.

Associativité
Si vous écrivez une expression de la forme a + b + c, où a, b et c sont des variables entières, vous appliquez deux
fois l’opérateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre ces opérations sont-elles
effectuées ? Est-ce que l’on a (a + b) + c ou a + (b + c) ? Cela importe peu, car le + entier est associatif, ce qui
signifie qu’il est possible de modifier le parenthèsage d’une somme d’entiers sans en changer le résultat. Attention :
l’associativité est une rareté ! Peu d’opérateurs sont associatifs, une bonne connaissance des règles sur les priorités et
le parenthèsage par défaut est donc requise.

Formes préfixes, postfixes, infixes

Un opérateur unaire est préfixe s’il se place avant son opérande, postfixe s’il se place après. Un opérateur binaire
est infixe s’il se place entre ses deux opérandes (a + b), préfixe s’il se place avant (+ a b), postfixe s’il se place
après (a b +). Vous rencontrez en C des opérateurs unaires préfixes et d’autres postfixes (on imagine difficilement un
opérateur unaire infixe), par contre tous les opérateurs binaires seront infixe.

Priorités
Les règles des priorités en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous appelerons
parenthèsage implicite le parenthèsage adopté par défaut par le C, c’est à dire l’ordre dans lequel il effectue les
opérations. La première règle à retenir est qu’un opérateur unaire est toujours prioritaire sur un opérateur binaire.

1.3.2 Les opérateurs unaires

Négation arithmétique
La négation arithmétique est l’opérateur − qui à une opérande x, associe l’opposé de x, c’est-à-dire le nombre qu’il
faut additionner à x pour obtenir 0.

Négation binaire
La négation binaire ~ agit directement sur les bits de son opérande, tous les bits à 0 deviennent 1, et vice-versa. Par
exemple, ~127 (tous les bits à 1 sauf le premier) est égal à 128 (le premier bit à 1 et tous les autres à 0).

Priorités
Tous les opérateurs unaires sont de priorité équivalente, le parenthèsage implicite est fait le plus à droite possible,
on dit que ces opérateurs sont associatifs à droite. Par exemple, le parenthèsage implicite de l’expression ~−~i est
~(−(~i)). C’est plutôt logique : si vous parvenez à placer les parenthèses différement, prevenez-moi parce que je ne
vois pas comment faire...

13
1.3.3 Les opérateurs binaires
Opérations de décalages de bits
L’opération a >> 1 effectue un décalage des bits de la représentation binaire de a vers la droite. Tous les bits sont
décalés d’un cran vers la droite, le dernier bit disparaît, le premier prend la valeur 0. L’opération a << 1 effectue
un décalage des bits de la représentation binaire de a vers la gauche. Tous les bits sont décalés d’un cran vers la
gauche, le premier bit disparaît et le dernier devient 0. Par exemple, 32 << 2 associe à 0010 0000 « 2 la valeur dont
la représentation binaire 1000 0000 et 32 » 3 associe à 0010 0000 » 3 la valeur dont la représentation binaire 0000
0100.

Opérations logiques sur la représentation binaire

L’opérateur & associe à deux opérandes le ET logique de leurs représentations binaires par exemple 60 & 15 donne 12,
autrement formulé 0011 1100 ET 0000 1111 = 0000 1100. L’opérateur | associe à deux opérandes le OU logique de
leurs représentations binaires par exemple 60 | 15 donne 63, autrement formulé 0011 1100 OU 0000 1111 = 0011
1111. L’opérateur ^ associe à deux opérandes le OU exclusif logique de leurs représentations binaires par exemple 60
^ 15 donne 51, autrement formulé 0011 1100 OU EXCLUSIF 0000 1111 = 0011 0011. Deux ^ successifs s’annulent,
en d’autres termes a^b^b=a.

Affectation
Ne vous en déplaise, le = est bien un opérateur binaire. Celui-ci affecte à l’opérande de gauche (appelée Lvalue par
le compilateur), qui doit être une variable, une valeur calculée à l’aide d’une expression, qui est l’opérande de droite.
Attention, il est possible d’effectuer une affectation pendant l’évaluation d’une expression. Par exemple,
a = b + ( c = 3) ;

Cette expression affecte à c la valeur 3, puis affecte à a la valeur b + c.

Priorités
Tous les opérateurs binaires ne sont pas de priorités équivalentes. Ceux de priorité la plus forte sont les opérateurs
arithmétiques (∗, /, &, +, −), puis les opérateus de décalage de bit (<<, >>), les opérateurs de bit (&, ^, | ), et enfin
l’affectation =. Représentons dans une tableau les opérateurs en fonction de leur priorité, plaçons les plus prioritaire en
haut et les moins prioritaires en bas. Parmi les opérateurs arithmétiques, les multiplications et divisions sont prioritaires
sur les sommes et différence :
noms opérateurs
produit *, /, %
sommes +, -
Les deux opérateurs de décalage sont de priorité équivalente :
noms opérateurs
décalage binaire », «
L’opérateur & est assimilé à un produit, | à une somme. Donc , & est prioritaire sur | . Comme ^ se trouve entre les
deux, on a
noms opérateurs
ET binaire &
OU Exlusif binaire ˆ
OU binaire |
Il ne nous reste plus qu’à assembler les tableaux :

14
 noms opérateurs
produit *, /, %
somme +, -
décalage binaire », «
ET binaire &
OU Exlusif binaire ˆ
OU binaire |
affectation =
Quand deux opérateurs sont de même priorité le parenthèsage implicite est fait le plus à gauche possible, on dit que
ces opérateurs sont associatifs à gauche. Par exemple, le parenthèsage implicite de l’expression a − b − c est
(a − b) − c

et certainement pas a − (b − c). Ayez donc cela en tête lorsque vous manipulez des opérateurs non associatifs ! La
seule exception est le =, qui est associatif à droite. Par exemple,
a = b = c;

se décompose en b = c suivi de a = b.

1.3.4 Formes contractées

Le C étant un langage de paresseux, tout à été fait pour que les programmeurs aient le moins de caractères possible
à saisir. Je vous préviens : j’ai placé ce chapitre pour que soyez capable de décrypter la bouillie que pondent certains
programmeurs, pas pour que vous les imitiez ! Alors vous allez me faire le plaisir de faire usage des formes contractées
avec parcimonie, n’oubliez pas qu’il est très important que votre code soit lisible.

Unaires
Il est possible d’incrémenter (augmenter de 1) la valeur d’une variable i en écrivant i++, ou bien ++i. De la même
façon on peut décrémenter (diminuer de 1) i en écrivant i−− (forme postfixe), ou bien −−i (forme préfixe). Vous
pouvez décider d’incrémenter (ou de décrémenter) la valeur d’une variable pendant un calcul, par exemple,
a = 1;
b = ( a++) + a ;

évalue successivement les deux opérandes a++ et a, puis affecte leur somme à b. L’opérande a++ est évaluée à 1,
puis est incrémentée, donc lorsque la deuxième opérande a est évaluée, sa valeur est 2. Donc la valeur de b après
l’incrémentation est 3. L’incrémentation contractée sous forme postfixe s’appelle une post-incrémentation. Si l’on
écrit,
a = 1;
b = (++a ) + a ;

On opère une pré-incrémentation, ++a donne lieu à une incrémentation avant l’évaluation de a, donc la valeur 4 est
affectée à b. On peut de façon analogue effectuer une pré-decrémentation ou a post-decrémentation. Soyez très
attentifs au fait que ce code n’est pas portable, il existe des compilateurs qui évaluent les opérandes dans le désordre
ou diffèrent les incrémentations, donnant ainsi des résultats autres que les résultats théoriques exposés précédement.
Vous n’utiliserez donc les incrémentation et decrémentation contractées que lorsque vous serez certain que l’ordre
d’évaluation des opérandes ne pourra pas influer sur le résultat.

Binaires
Toutes les affectations de la forme variable = variable operateurBinaire expression peuvent être contractées sous la
forme variable operateurBinaire= expression. Par exemple,

15
 avant après
a = a + b a += b
a = a - b a -= b
a = a * b a *= b
a = a / b a /= b
a = a % b a %= b
a = a » i a »= i
a = a « i a «= i
a = a & b a &= b
a = a ˆ b a ˆ= b
a = a | b a |= b
Vous vous douterez que l’égalité ne peut pas être contractée...

1.3.5 Opérations hétérogènes

Le fonctionnement par défaut
Nous ordonnons de façon grossière les types de la façon suivante : long double > double > float > unsigned
long > long > unsigned int > int > unsigned short > short > char. Dans un calcul où les opérandes sont de
types hétérogènes, l’opérande dont le type T est de niveau le plus élévé (conformément à l’ordre énoncé ci-avant) est
sélectionné et l’autre est converti dans le type T .

Le problème
1
Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer l’inverse
x
d’un nombre entier x, et que vous codez
int i = 4 ;
printf ( "L ’ inverse de %d est %d" , i , 1/ i ) ;

Vous constaterez que résultat est inintéressant au possible. En effet, comme i et 1 sont tout deux de type entier, c’est
la division entière est effectuée, et de toute évidence le résultat est 0. Changer la chaîne de format
int i = 4 ;
printf ( "L ’ inverse de %d est %f\n" , i , 1/ i ) ;

se révèlera aussi d’une inefficacité notoire : non seulement vous vous taperez un warning, mais en plus printf lira un
entier en croyant que c’est un flottant. Alors comment on se sort de là ? Ici la bidouille est simple, il suffit d’écrire le
1 avec un point :

int i = 4 ;
printf ( "L ’ inverse de %d est %f\n" , i , 1 . / i ) ;

Le compilateur, voyant un opérande de type flottant, convertit lors du calcul l’autre opérande, i, en flottant. De ce
fait, c’est une division flottante et non entière qui est effectuée. Allons plus loin : comment faire pour appliquer une
division flottante à deux entiers ? Par exemple :
i n t i = 4 , j= 5 ;
printf ( " Le quotient de %d et %d est %f\n" , i , j , i/j ) ;

Cette fois-ci c’est inextricable, vous pouvez placer des points où vous voudrez, vous n’arriverez pas à vous débarasser
du warning et ce programme persistera à vous dire que ce quotient est -0.000000 ! Une solution particulièrement crade
serait de recopier i et j dans des variables flottantes avant de faire la division, une autre méthode de bourrin est de
calculer (i + 0.)/j. Mais j’espère que vous réalisez que seuls les boeufs procèdent de la sorte.

16
Le cast
Le seul moyen de vous sortir de là est d’effectuer un cast, c’est à dire une conversion de type sur commande. On caste
en plaçant entre parenthèse le type dans lequel on veut convertir juste avant l’opérande que l’on veut convertir. Par
exemple,
i n t i = 4 , j= 5 ;
printf ( " Le quotient de %d et %d est %f\n" , i , j , ( f l o a t ) i/j ) ;

Et là, ça fonctionne. La variable valeur contenue dans i est convertie en float et de ce fait, l’autre opérande, j, est
aussi convertie en float. La division est donc une division flottante. Notez bien que le cast est un opérateur unaire,
donc prioritaire sur la division qui est un opérateur binaire, c’est pour ça que la conversion de i a lieu avant la division.
Mais si jamais il vous vient l’idée saugrenue d’écrire
i n t i = 4 , j= 5 ;
printf ( " Le quotient de %d et %d est %f\n" , i , j , ( f l o a t ) ( i/j ) ) ;

Vous constaterez très rapidement que c’est une alternative peu intelligente. En effet, le résulat est flottant, mais comme
la division a lieu avant toute conversion, c’est le résultat d’une division entière qui est converti en flottant, vous avez
donc le même résultat que si vous n’aviez pas du tout casté.

1.3.6 Les priorités

Ajoutons le cast au tableau des priorités de nos opérateurs :
noms opérateurs
opérateurs unaires cast, -, , ++, –
produit *, /, %
somme +, -
décalage binaire », «
ET binaire &
OU Exlusif binaire ˆ
OU binaire |
affectation =

17
1.4 Traitements conditionnels
On appelle traitement conditionnel une portion de code qui n’est pas exécutée systématiquement, c’est à dire des
instructions dont l’exécution est conditionnée par le succès d’un test.

1.4.1 Si ... Alors

Principe
En algorithmique un traitement conditionnel se rédige de la sorte :
Si condition alors
instructions
Fin si
Si la condition est vérifiée, alors les instructions sont exécutées, sinon, elles ne sont pas exécutées. L’exécution de l’algo-
rithme se poursuit alors en ignorant les instructions se trouvant entre le alors et le finSi. Un traitement conditionnel
se code de la sorte :
i f (<condition >)
{
<instructions>
}

Notez bien qu’il n’y a pas de point-virgule après la parenthèse du if .

Comparaisons
La formulation d’une condition se fait souvent à l’aide des opérateurs de comparaison. Les opérateurs de comparaison
disponibles sont :
— == : égalité
— != : non-égalité
— <, <= : inférieur à, respectivement strict et large
— >, >= : supérieur à, respectivement strict et large
Par exemple, la condition a == b est vérifiée si et seulement si a et b ont la même valeur au moment où le test est
évalué. Par exemple,
#include<s t d i o . h>

i n t main ( )
{
int i ;
printf ( " Saisissez une valeur : " ) ;
scanf ( "%d" , &i ) ;
i f ( i == 0 )
{
printf ( " Vous avez saisi une valeur nulle \n." ) ;
}
printf ( " Adios !" ) ;
return 0 ;
}

Si au moment où le test i == 0 est évalué, la valeur de i est bien 0, alors le test sera vérifié et l’instruction printf("
Vous avez saisi une valeur nulle.") sera bien exécutée. Si le test n’est pas vérifié, les instructions du bloc délimité
par des accolades suivant le if sont ignorées.

Si ... Alors ... Sinon

Il existe une forme étendue de traitement conditionnel, on la note en algorithmique de la façon suivante :

18
 Si condition alors
instructions
Sinon
autresinstructions
Fin si
Les instructions délimitées par alors et sinon sont exécutées si le test est vérifié, et les instructions délimitées par
sinon et finSi sont exécutées si le test n’est pas vérifié. On traduit le traitement conditionnel étendu de la sorte :

i f (<condition >)
{
<instructions1>
}
else
{
<instructions2>
}

Par exemple,
#include<s t d i o . h>

i n t main ( )
{
int i ;
printf ( " Saisissez une valeur : " ) ;
scanf ( "%d" , &i ) ;
i f ( i == 0 )
{
printf ( " Vous avez saisi une valeur nulle \n." ) ;
}
else
{
printf ( " La valeur que vous saisi , "
"a savoir %d , n ’est pas nulle .\ n" , i ) ;
}
return 0 ;
}

Notez la présence de l’opérateur de comparaison ==. N’utilisez jamais = pour comparer deux valeurs !.

Connecteurs logiques
On formule des conditions davantage élaborées en utilisant des connecteurs et et ou. La condition A et B est vérifiée
si les deux conditions A et B sont vérifiées simultanément. La condition A ou B est vérifiée si au moins une des deux
conditions A et B est vérifiée. Le et s’écrit && et le ou s’écrit || . Par exemple, voici un programme C qui nous donne
le signe de i × j sans les multiplier.
#include<s t d i o . h>

i n t main ( )
{
int i , j ;
printf ( " Saisissez deux valeurs : " ) ;
scanf ( "%d %d" , &i , &j ) ;
printf ( " Le produit de ces deux valeurs est " ) ;
i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
{
printf ( " positif \n." ) ;
}

19
 else
{
printf ( " negatif " ) ;
}
printf ( " .\ n" ) ;
return 0 ;
}

Accolades superflues
Lorsqu’une seule instruction d’un bloc if doit être exécutée, les accolades ne sont plus nécessaires. Il est possible par
exemple de reformuler le programme précédent de la sorte :
#include<s t d i o . h>

i n t main ( )
{
int i , j ;
printf ( " Saisissez deux valeurs : " ) ;
scanf ( "%d %d" , &i , &j ) ;
printf ( " Le produit de ces deux valeurs est " ) ;
i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
printf ( " positif \n." ) ;
else
printf ( " negatif " ) ;
printf ( " .\ n" ) ;
return 0 ;
}

Opérateur ternaire
En plaçant l’instruction suivante à droite d’une affectation,
<variable> = (<condition >) ? <valeur> : <autrevaleur> ;

on place valeur dans variable si condition est vérifié, autrevaleur sinon. Par exemple,
max = ( i>j ) ? i : j ;

place la plus grande des deux valeurs i et j dans max. Plus généralement on peut utiliser le si ternaire dans n’importe
quel calcul, par exemple
printf ( "%d\n" , ( i> ( l = ( j>k ) ? j : k ) ) ? i : l ) ;

j = (j>k)? j : k) place dans l la plus grande des valeurs j et k, donc (i > (l = (j > k)? j : k)) ? i : l est la plus
grande des valeurs i, j et k. La plus grande de ces trois valeurs est donc affichée par cette instruction.

1.4.2 Switch
Le switch en C s’écrit, avec la syntaxe suivante :
switch(<nomvariable >)
{
case <valeur_1> : <instructions_1> ; break ;
case <valeur_2> : <instructions_2> ; break ;
/∗ . . . ∗/
case <valeur_n> : <instructions_n> ; break ;
default : /∗ i n s t r u c t i o n s ∗/
}

20
N’oubliez surtout pas les break ! Si par exemple, nous voulons afficher le nom d’un mois en fonction de son numéro,
on écrit
switch ( numeroMois )
{
case 1 : printf ( " janvier " ) ; break ;
case 2 : printf ( " fevrier " ) ; break ;
case 3 : printf ( " mars " ) ; break ;
case 4 : printf ( " avril " ) ; break ;
case 5 : printf ( " mai " ) ; break ;
case 6 : printf ( " juin " ) ; break ;
case 7 : printf ( " juillet " ) ; break ;
case 8 : printf ( " aout " ) ; break ;
case 9 : printf ( " septembre " ) ; break ;
case 10 : printf ( " octobre " ) ; break ;
case 11 : printf ( " novembre " ) ; break ;
case 12 : printf ( " decembre " ) ; break ;
default : printf ( " Je connais pas ce mois ... " ) ;
}

1.4.3 Booléens
Une variable booléenne ne peut prendre que deux valeurs : vrai et f aux. Il n’existe pas de type booléen à proprement
parler en C. On utilise des int pour simuler le comportement des booléens. On représente la valeur booléenne f aux
avec la valeur entière 0, toutes les autres valeurs entières servent à représenter vrai.

Utilisation dans des if

Lorsqu’une condition est évaluée, par exemple lors d’un test, cette condition prend à ce moment la valeur vrai si le
test est vérifié, f aux dans le cas contraire. La valeur entière 0 représente la constante f aux et toutes les autres sont
des constantes vrai. Observons le test suivant :
i f (8)
{
// . . .
}

1 est un littéral de type entier dont le valeur est non nulle, donc il représente le booléen vrai. De ce fait, le test if (8)
est toujours vérifié. Par contre le test if (0) n’est jamais vérifié.

La valeur vrai
Même si tout entier non nul a la valeur vrai, on prend par défaut la valeur 1. Lorsqu’une condition est évaluée, elle
prend la valeur 1 si elle est vérifié, 0 dans le cas contraire. par exemple,
x = (3 >2) ;

On remarque que (3>2) est une condition. Pour décider quelle valeur doit être affectée à x, cette condition est évaluée.
Comme dans l’exemple ci-dessus la condition est vérifiée, alors elle prend la valeur 1, et cette valeur est affectée à x.

Connecteurs logiques binaires

Les connecteurs || et && peuvent s’appliquer à des valeurs (ou variables) entières. Observons l’exemple suivant :
x = ( 3 && 0 ) | | ( 1 ) ;

Il s’agit de l’affectation à x de l’évaluation de la condition (3 && 0) || (1) . Comme 3 est vrai et 0 est faux, alors leur
conjonction est fausse. Donc (3 && 0) a pour valeur 0. La condition 0 || 1 est ensuite évaluée et prend la valeur vrai.
Donc la valeur 1 est affectée à x.

21
Opérateur de négation
Parmi les connecteurs logiques se trouve ! , dit opérateur de négation. La négation d’une expression est vraie si
l’expression est fausse, fausse si l’expression est vraie. Par exemple,
x = !(3==2) ;

Comme 3 == 2 est faux, alors sa négation !(3 == 2) est vraie. Donc la valeur 1 est affectée à x.

1.4.4 Les priorités

Complètons notre tableau des priorités en y adjoignant les connecteurs logiques et les opérateurs de comparaison :
noms opérateurs
opérateurs unaires cast, -, ˜, !, ++, –
produit *, /, %
somme +, -
décalage binaire », «
comparaison >, <, >=, <=
égalité ==, !=
ET binaire &
OU Exlusif binaire ˆ
OU binaire |
connecteurs logiques &&, ||
if ternaire ()?:
affectations =, +=, -=, . . .

1.4.5 Préprocesseur
Macro-instructions
Le C nous permet de placer à peu près n’importe quoi dans les constantes. Si par exemple, on est lassé d’écrire des
instructions de retour à la ligne, il suffit de définir
#define RC p r i n t f ( "\n" )

Dans ce cas, toutes les occurrences de RC dans le code seront remplacées par des printf("$\setminus$n"). Par exemple
#include<s t d i o . h>

#define BEGIN {
#define END }

#define RC p r i n t f ( "\n" )
#define AFFICHE_DEBUT p r i n t f ( " Debut " )
#define AFFICHE_FIN p r i n t f ( " Fin " )
#define AFFICHE_MLILIEU p r i n t f ( " Milieu " )
#define RETOURNE_0 return 0

i n t main ( )
BEGIN
AFFICHE_DEBUT ;
RC ;
AFFICHE_MLILIEU ;
RC ;
AFFICHE_FIN ;
RC ;
RETOURNE_0 ;
END

22
affiche

Debut
Milieu
Fin

Macros paramétrées
Il est possible de paramétrer les instructions du préprocesseur. Par exemple,
#define TROIS_FOIS_N( n ) ( 3 ∗ ( n ) )

va remplacer toutes les occurences de TROIS\_FOIS\_N(...) par (3 ∗ (...) ) en substituant aux points de suspension la
valeur se trouvant entre les parenthèses de la constante. Par exemple
#include<s t d i o . h>

#define RC p r i n t f ( "\n" )
#define DECLARER_INT( i ) i n t i
#define AFFICHER_INT( i ) p r i n t f ( "%d" , i )
#define SAISIR_INT ( i ) s c a n f ( "%d" , &i )

i n t main ( )
{
DECLARER_INT ( k ) ;
printf ( " Saisissez un entier : " ) ;
SAISIR_INT ( k ) ;
printf ( " Vous avez saisi " ) ;
AFFICHER_INT ( k ) ;
RC ;
return 0 ;
}

affiche

Saisissez un entier : 4
Vous avez saisi 4

23
1.5 Boucles
Nous souhaitons créer un programme qui nous affiche tous les nombres de 1 à 10, donc dont l’exécution serait la
suivante :

1 2 3 4 5 6 7 8 9 10

Une façon particulièrement vilaine de procéder serait d’ecrire 10 printf successifs, avec la lourdeur des copier/coller
que cela impliquerait. Nous allons étudier un moyen de coder ce type de programme avec un peu plus d’élégance.

1.5.1 Définitions et terminologie

Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cette ensemble d’instructions
s’appelle le corps de la boucle. Chaque exécution du corps d’une boucle s’appelle une itération, ou plus informellement
un passage dans la boucle. Lorsque l’on s’apprête à exécuter la première itération, on dit que l’on rentre dans la
boucle, lorsque la dernière itération est terminée, on dit qu’on sort de la boucle. Il existe trois types de boucle :
— while
— do ... while
— for
Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue ultérieurement.

1.5.2 while

En C, la boucle tant que se code de la façon suivante :

while(<condition >)
{
<instructions>
}

Les instructions du corps de la boucle sont délimitées par des accolades. La condition est évaluée avant chaque passage
dans la boucle, à chaque fois qu’elle est vérifiée, on exécute les instructions de la boucle. Un fois que la condition n’est
plus vérifiée, l’exécution se poursuit après l’accolade fermante. Affichons par exemple tous les nombres de 1 à 5 dans
l’ordre croissant,
#include<s t d i o . h>

i n t main ( )
{
int i = 1 ;
while ( i <= 5 )
{
printf ( "%d " , i ) ;
i++;
}
printf ( "\n" ) ;
return 0 ;
}

Ce programme initialise i à 1 et tant que la valeur de i n’éxcède pas 5, cette valeur est affichée puis incrémentée.
Les instructions se trouvant dans le corps de la boucle sont donc exécutées 5 fois de suite. La variable i s’appelle un
compteur, on gère la boucle par incrémentations successives de i et on sort de la boucle une fois que i a atteint une
certaine valeur. L’initialisation du compteur est très importante ! Si vous n’initialisez pas i explicitement, alors
cette variable contiendra n’importe quelle valeur et votre programme ne se comportera pas du tout comme prévu.
Notez bien par ailleurs qu’il n’y a pas de point-virgule après le while !

24
1.5.3 do ... while

Voici la syntaxe de cette boucle :

do
{
<instructions>
}
while(<condition >) ;

La fonctionnement est analogue à celui de la boucle tant que à quelques détails près :
— la condition est évaluée après chaque passage dans la boucle.
— On exécute le corps de la boucle tant que la condition est vérifée.
En C, la boucle répéter ... jusqu’à est en fait une boucle répéter ... tant que, c’est-à-dire une boucle tant que dans
laquelle la condition est évaluée à la fin. Une boucle do ... while est donc exécutée donc au moins une fois.
Reprennons l’exemple précédent avec une boucle do ... while :
#include<s t d i o . h>

i n t main ( )
{
int i = 1 ;
do
{
printf ( "%d " , i ) ;
i++;
}
while ( i <= 5 ) ;
printf ( "\n" ) ;
return 0 ;
}

De la même façon que pour la boucle while, le compteur est initialisé avant le premier passage dans la boucle. Un des
usages les plus courant de la boucle do ... while est le contrôle de saisie :
#include<s t d i o . h>

i n t main ( )
{
int i ;
do
{
printf ( " Saisissez un entier positif ou nul : " ) ;
scanf ( "%d" , &i ) ;
i f ( i < 0)
printf ( "J ’ai dit positif ou nul ! ‘\n" ) ;
}
while ( i < 0 ) ;
return 0 ;
}

1.5.4 for

Cette boucle est quelque peu délicate. Commençons par donner sa syntaxe :
f o r (<initialisation> ; <condition> ; <pas >)
{
<instructions>
}

25
L’<initialisation> est une instruction exécutée avant le premier passage dans la boucle. La <condition> est évaluée
avant chaque passage dans la boucle, si elle n’est pas vérifiée, on ne passe pas dans la boucle et l’exécution de la boucle
pour est terminée. La <pas> est une instruction exécutée après chaque passage dans la boucle. On peut convertir une
boucle for en boucle while en procédant de la sorte :
<initialisation>
while(<condition >)
{
<instructions>
<pas>
}

On re-écrit l’affiche des 5 premiers entiers de la sorte en utilisant le fait que <initialisation> = i = 1, <condition>
= i <= 5 et <pas> = i++. On obtient :
#include<s t d i o . h>

i n t main ( )
{
int i ;
f o r ( i = 1 ; i <= 5 ; i++)
printf ( "%d " , i ) ;
printf ( "\n" ) ;
return 0 ;
}

On utilise une boucle for lorsque l’on connait en entrant dans la boucle combien d’itérations devront être faites. Par
exemple, n’utilisez pas une boucle pour pour contrôler une saisie !

1.5.5 Accolades superflues

De la même façon qu’il est possibl de supprimer des accolades autour d’une instruction d’un bloc if , on peut supprimer
les accolades autour du corps d’une boucle si elle ne contient qu’une seule instruction.

26
1.6 Tableaux
Considérons un programme dont l’exécution donne :

Saisissez dix valeurs :

1 : 4
2 : 7
3 : 34
4 : 1
5 : 88
6 : 22
7 : 74
8 : 19
9 : 3
10 : 51
Saissez une valeur
22
22 est la 6-eme valeur saisie

Comment programmer cela sans utiliser 10 variables pour stocker les dix premières valeurs saisies ?

1.6.1 Définitions
Une tableau est un regroupement de variables de même type, il est identifié par un nom. Chacune des variables du
tableau est numérotée, ce numéro s’appelle un indice. Chaque variable du tableau est donc caractérisée par le nom
du tableau et son indice.

Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera numérotée et il sera possible de la re-
trouver en utilisant simultanément le nom du tableau et l’indice de la variable. Les différentes variables de T porteront
des numéros de 0 à 9, et nous appellerons chacune de ces variables un élément de T .

Une variable n’étant pas un tableau est appelée variable scalaire, un tableau par opposition à une variable scalaire
est une variable non scalaire.

1.6.2 Déclaration
Comme les variables d’un tableau doivent être de même type, il convient de préciser ce type au moment de la délaration
du tableau. De même, on précise lors de la déclaration du tableau le nombre de variables qu’il contient. La syntaxe
est :
<type> <nomdutableau >[<taille > ] ;

Par exemple,
int T [ 4 ] ;

déclare un tableau T contenant 4 variables de type int.

1.6.3 Initialisation
Il est possible d’initialiser les éléments d’un tableau à la déclaration, on fait cela comme pour des variables scalaires :
<type> <nom >[<taille >] = <valeur d initialisation >;

La seule chose qui change est la façon d’écrire la valeur d’initialisation, on ecrit entre accolades tous les éléments du
tableau, on les dispose par ordre d’indice croissant en les séparant par des virgules. La syntaxe générale de la valeur
d’initialisation est donc :

27
<type> <nom >[<taille >] = {<valeur_0 >, <valeur_1 >, . . . , <valeur_n −1>};

Par exemple, on crée un tableau contenant les 5 premiers nombres impairs de la sorte :
int T [ 5 ] = {1 , 3 , 5 , 7 , 9 } ;

1.6.4 Accès aux éléments

Les éléments d’un tableau à n éléments sont indicés de 0 à n − 1. On note T[i] l’élément d’indice i du tableau T. Les
cinq éléments du tableau de l’exemple ci-avant sont donc notés T [0] , T [1] , T [2] , T [3] et T [4] .

1.6.5 Exemple
Nous pouvons maintenant mettre en place le programme du début du cours. Il est nécessaire de stocker 10 valeurs de
type entier, nous allons donc déclarer un tableau E de la sorte :
int E [ 1 0 ] ;

La déclaration ci-dessus est celle d’un tableau de 10 int appelé E. Il convient ensuite d’effectuer les saisies des 10
valeurs. On peut par exemple procéder de la sorte :
printf ( " Saisissez dix valeurs : \n" ) ;
printf ( "1" ) ;
scanf(%d" , &E [0]) ;
printf ("2");
scanf (% d" , &E [ 1 ] ) ;
printf ( "3" ) ;
scanf(%d" , &E [2]) ;
printf ("4");
scanf (% d" , &E [ 3 ] ) ;
printf ( "5" ) ;
scanf(%d" , &E [4]) ;
printf ("6");
scanf (% d" , &E [ 5 ] ) ;
printf ( "7" ) ;
scanf(%d" , &E [6]) ;
printf ("8");
scanf (% d" , &E [ 7 ] ) ;
printf ( "9" ) ;
scanf(%d" , &E [8]) ;
printf (" 10 ");
scanf (% d" , &E [ 9 ] ) ;

Les divers copier/coller necéssaires pour rédiger un tel code sont d’une laideur à proscrire. Nous procéderons plus
élégament en faisant une boucle :
printf ( " Saisissez dix valeurs : \n" ) ;
f o r ( i = 0 ; i < 10 ; i++)
{
printf ( "%d" , i+1) ;
scanf ( "%d" , &E [ i ] ) ;
}

Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des boucles pour manier les tableaux,
celles-ci permettent d’effectuer un traitement sur chaque élément d’un tableau. Ensuite, il faut saisir une valeur à
rechercher dans le tableau :
printf ( " Saissez une valeur \n" ) ;
scanf ( "%d" , &t ) ;

28
Nous allons maintenant rechercher la valeur t dans le tableau E. Considérons pour ce faire la boucle suivante :
while ( E [ i ] != t )
i++;

Cette boucle parcourt le tableau jusqu’à trouver un élément de E qui ait la même valeur que t. Le problème qui
pourrait se poser est que si t ne se trouve pas dans le tableau E, alors la boucle pourrait ne pas s’arrêter. Si i prend
des valeurs strictement plus grandes que 9, alors il se produira ce que l’on appelle un débordement d’indice. Vous
devez toujours veiller à ce qu’il ne se produise pas de débordement d’indice ! Nous allons donc faire en sorte que la
boucle s’arrête si i prend des valeurs strictement supérieures à 9.
while ( i < 10 && E [ i ] != t )
i++;

Il existe donc deux façons de sortir de la boucle :

— En cas de débordement d’indice, la condition i < 10 ne sera pas vérifiée. Une fois sorti de la boucle, i aura la
valeur 10.
— Dans le cas où t se trouve dans le tableau à l’indice i, alors la condition E[i] != t ne sera pas vérifiée et on
sortira de la boucle. Un fois sorti de la boucle, i aura comme valeur l’indice de l’élément de E qui est égal à t,
donc une valeur comprise entre 0 et 9.
On identifie donc la façon dont on est sorti de la boucle en testant la valeur de i :
i f ( i == 1 0 )
printf ( "%d ne fait pas partie des dix valeurs saisies " , t ) ;
else
printf ( "%d est la %d - eme valeur saisie " , t , i+1) ;

Si (i == 10), alors nous sommes sorti de la boucle parce que l’élément saisi par l’utilisateur ne trouve pas dans le
tableau. Dans le cas contraire, t est la i+1-ème valeur saisie par l’utilisateur. On additionne 1 à l’indice parce que
l’utilisateur ne sait pas que dans le tableau les éléments sont indicés à partir de 0. Récapitulons :
#include<s t d i o . h>

#define N 10

i n t main ( )
{
int E [ N ] , i , t ;
printf ( " Saisissez dix valeurs : \n" ) ;
f o r ( i = 0 ; i < N ; i++)
{
printf ( "%d : " , i+1) ;
scanf ( "%d" , &E [ i ] ) ;
}
printf ( " Saissez une valeur \n" ) ;
scanf ( "%d" , &t ) ;
i = 0;
while ( i < N && E [ i ] != t )
{ printf ( "%d %d\n" , i , E [ i ] ) ; i++;}
i f ( i == N )
printf ( "%d ne fait pas partie des dix valeurs saisies " , t ) ;
else
printf ( "%d est la %d - eme valeur saisie " , t , i+1) ;
printf ( "\n" ) ;
return 0 ;
}

29
1.7 Chaînes de caractères
1.7.1 Exemple
Etant donné le programme dont l’exécution est tracée ci dessous :

Saisissez une phrase :

Les framboises sont perchees sur le tabouret de mon grand-pere.
Vous avez saisi :
Les framboises sont perchees sur le tabouret de mon grand-pere.
Cette phrase commence par une majuscule.
Cette phrase se termine par un point.

Comment faire pour saisir et manier des séquences de caractères de la sorte ?

1.7.2 Définition
Une chaîne de caractères est un tableau de char contenant un caractère nul. Le caractère nul a 0 pour code
ASCII et s’écrit ’\0’. Les valeurs significatives de la chaîne de caractères sont toutes celles placées avant le caractère
nul. On remarque donc que si le caractère nul est en première position, on a une chaine de caractères vide.

Par exemple, la phrase "Toto" sera codée de la sorte :

’T’ ’o’ ’t’ ’o’ 0 . . .
Prenez bien note du fait que le dernier caractère de la chaine est suivi d’un caractère nul.

1.7.3 Déclaration
Comme une chaîne de caractères est un tableau de char, on le déclare :
char <nom_chaine >[<taille_chaine > ] ;

Par exemple, on déclare une chaine c de 200 caractères de la sorte :

char c [ 2 0 0 ] ;

Attention ! Le nombre maximal de lettres qu’il sera possible de placer dans c ne sera certainement pas 200 mais 199,
car il faut placer après le dernier caractère de la chaîne un caractère nul !

1.7.4 Initialisation
On initialise une chaîne à la déclaration, et seulement à la déclaration de la sorte :
char <nom_chaine >[<taille_chaine >] = <valeur_initialisation >;

Où la valeur d’initiallisation contient la juxtaposition de caractères formant la chaîne entourée de guillemets (double
quotes). Par exemple,
char c [ 5 0 ] = " Toto " ;

Cette instruction déclare une chaîne de caratères c initialisée à "Toto". Les 5 premiers éléments du tableau seront occu-
pés par les 4 caractères de la chaîne ainsi que par le caratère nul, les autres contiendront des valeurs non significatives.
Observez bien l’exemple suivant :
char c [ 4 ] = " Toto " ;

Cette déclaration engendrera un warning à la compilation et probablement une erreur à l’exécution car l’affectation
du caractère nul à la 5-ème position du tableau donnera lieu à un débordement d’indice.

30
1.7.5 Accès aux éléments
Du fait qu’une chaine de caractère est un tableau, il est aisé d’en isoler un élément. Ainsi c[i] est le i+1-ème élément
de la chaîne c. On teste donc si le premier caratère de c est une majuscule de la sorte :
i f ( c [ 0 ] >= ’A ’ && c [ 0 ] <= ’Z ’ )
printf ( " Cette phrase commence par une majuscule .\ n" ) ;
else
printf ( " Cette phrase ne commence pas par une majuscule .\ n" ) ;

Cette propriété permet aussi d’afficher une chaîne caractère par caractère :
int i = 0 ;
while ( c [ i ] != 0 )
printf ( "%c" , c [ i++]) ;

Notez que le corps de la boucle while est itéré jusqu’à ce que le caractère nul soit rencontré. Il est donc impératif
que votre chaîne se termine par le caractère nul et que le caractère nul se trouve dans la plage d’indices
du tableau. Est-ce que le code suivant est correct ?
char c [ 2 6 ] ;
int i ;
f o r ( i = 0 ; i < 2 6 , i++)
c [ i ] = ’a ’ + i ;

Si la question vous est posée, vous pouvez présumer que ce code n’est pas correct. Le fait que chaque élément du
tableau contienne un caractère non nul ne peut que corroborer cette présomption... Si l’on souhaite placer l’alphabet
dans une chaîne, on procède de la sorte :
char c [ 2 7 ] ;
int i ;
f o r ( i = 0 ; i < 2 6 , i++)
c [ i ] = ’a ’ + i ;
c [26] = 0;

Notez bien que le tableau contient 27 éléments si l’on compte le caractère nul, et que celui-ci est placé à la fin du
tableau juste après la boucle.

1.7.6 Affichage
Nous avons vu qu’il était possible d’utiliser le fait qu’une chaîne est un tableau pour l’afficher. Il existe une méthode
plus simple, en utilisant printf avec la chaîne de format "%s". Par contre soyez attentifs au fait que si votre chaîne ne
contient pas de caractère nul ou que le caractère nul se trouve en dehors de la plage d’indice de votre chaîne, il faudra
vous attendre aux pires horreurs à l’exécution ! Dans le code donné en exemple nous pouvons donc écrire l’instruction
d’affichage de la chaîne saisie par l’utilisateur :
printf ( " Vous avez saisi :\ n%s" , c ) ;

1.7.7 Saisie
C’est maintenant que les choses se corsent, il faut être très attentif lors des saisies : tout débordement d’indice
et/ou absence de caratère nul peut donner lieu à des bugs très difficiles à trouver ! La plus grande vigilance est
donc de mise. Beaucoup d’amateurs utilisent des fonctions comme gets. Par exemple,
#include<s t d i o . h>

#define N 20

i n t main ( )
{

31
 char chaine [ N ] ;
int i ;
printf ( " Saisissez une phrase :\ n" ) ;
// g e t s ( c h a i n e ) ;
f o r ( i = 0 ; chaine [ i ] != 0 ; i++)
printf ( " chaine [% d] = %c ( code ASCII : %d)\n" , i , chaine [ i ] , chaine [ i ] ) ;
printf ( " chaine [% d] = %c ( code ASCII : %d)\n" , i , chaine [ i ] , chaine [ i ] ) ;
return 0 ;
}

Tout d’abord compilons ce programme :

[klaus@Isengard chaines]$ gcc -Wall mauvaiseSaisie.c -o mauvaiseSaisie.c

/home/klaus/tmp/ccyKd0hf.o: In function ‘main’:
mauvaiseSaisie.c:(.text+0x24): warning: the ‘gets’ function is
dangerous and should not be used.

La première réaction du compilateur est une insulte. A-t-il raison ? Testons ce programme :

[klaus@Isengard chaines]$ ./mauvaiseSaisie

Saisissez une phrase :
Les framboises sont perchees sur le tabouret de mon grand pere.
chaine[0] = L (code ASCII : 76)
chaine[1] = e (code ASCII : 101)
chaine[2] = s (code ASCII : 115)
chaine[3] = (code ASCII : 32)
chaine[4] = f (code ASCII : 102)
chaine[5] = r (code ASCII : 114)
chaine[6] = a (code ASCII : 97)
chaine[7] = m (code ASCII : 109)
chaine[8] = b (code ASCII : 98)
chaine[9] = o (code ASCII : 111)
chaine[10] = i (code ASCII : 105)
chaine[11] = s (code ASCII : 115)
chaine[12] = e (code ASCII : 101)
chaine[13] = s (code ASCII : 115)
chaine[14] = (code ASCII : 32)
chaine[15] = s (code ASCII : 115)
chaine[16] = o (code ASCII : 111)
chaine[17] = n (code ASCII : 110)
chaine[18] = t (code ASCII : 116)
chaine[19] = (code ASCII : 32)
chaine[20] = (code ASCII : 20)
chaine[21] = (code ASCII : 0)
Erreur de segmentation

Que se passe-t-il ? Des horreurs ! La fonction gets est la pire des choses qui puisse arriver à un programme C ! Ne
l’utilisez sous aucun prétexte ! Maintenant, nous allons envisager une façon propre de saisir une chaîne de caractère :
fgets. La syntaxe est la suivante :
fgets(<chaine >, <taille >, stdin ) ;

La taille de la chaîne saisie est limitée par <taille>, caractère nul compris. Le résultat est placé dans <chaine>. Tous
les caractères supplémentaires saisis par l’utilisateur ne sont pas placés dans <chaine>, seuls les taille − 1 premiers
caractères sont récupérés par fgets. Nous saisirons donc la phrase de notre programme de la sorte :
fgets ( c , 2 0 0 , stdin ) ;

32
1.7.8 Problèmes liés à la saisie bufferisée
Lorsque vous saisissez des caractères avec fgets, les caractères ignorés ne sont pas éliminés du buffer. Cela signifie
qu’ils iront parasiter la prochaine saisie. Il convient donc tout d’abord de vérifier s’il reste des caractères dans buffer
et de les éliminer si nécessaire. Commençons par le premier point : comment s’assurer que tous les caractères saisis
ont été lus ? La réponse est très simple : grâce au caractère d’échappement ’\n’. La saisie est validée par le caratère
d’échappement, il s’agit donc toujours du dernier caractère saisi. Le buffer a donc été entirèrement lu si caractère
d’échappement a été lu. Si ce caractère a été lu, alors il figure juste avant le caractère nul dans la chaîne. On le repère
donc de la sorte :
while ( c [ i ] != 0 )
i++;
i f ( c [ i −1] != ’\n ’ )
printf ( " La saisie est incomplete " ) ;
else
printf ( " La saisie est complete " ) ;

Si la chaîne c a été saisie correctement, aucun risque de débordement d’indice ou de bouclage infini ne peut se présenter.
La boucle au début de l’extrait recherche le caractère nul dans la chaîne. On sort de la boucle quand c[i] == 0, donc
l’indice du caratère nul est i. Si l’avant dernier caractère de la chaîne, donc celui d’indice (i − 1) est le caractère
d’échappement, alors la saisie a été complète et le buffer est vide. Sinon, c’est que des caractères ont été laissés dans le
buffer par fgets. Il convient donc, si l’on souhaite effectuer d’autres saisies par la suite, de vider le buffer. getchar est
une instruction retournant un caractère lu dans le buffer. Si le buffer est vide, getchar attend une saisie de l’utilisateur
non validée par le caractère d’échappement ! On vide donc le buffer de la sorte :
while ( getchar ( ) != ’\n ’ ) ;

Le point-virgule à la fin de l’instruction indique au compilateur que la boucle n’a pas de corps. Cette boucle lit le
buffer jusqu’à ce que le caractère d’échappement ait été lu. Pour davantage de lisibilité, on définit une macro-instruction
vidant le buffer :
#define CLEAR_BUFFER while ( getchar ( ) != ’\n ’ )

Vérifiez bien avant de lancer cette instruction que le buffer n’est pas vide, sinon le programme bouclera jusqu’à ce que
l’utilisateur ait saisi un caractère d’échappement.

1.7.9 La bibliothèque string . h

Cette bibliothèque propose des fonctions de maniement de chaînes de caractères, à savoir :

— strcmp : comparer deux chaînes.
— strlen : longueur d’une chaîne de caractère
— strsubs : rechercher une sous-chaîne
— strcat : concaténer deux chaînes
— strcpy : copier une chaîne
Il vous est conseillé d’examiner de quelle façon fonctionnent ces fonctions, et comment elles gèrent le caractère nul.

1.7.10 Exemple

#include<s t d i o . h>

#define N 10
#define CLEAR_BUFFER while ( g e t c h a r ( ) != ’\n ’ )

i n t main ( )
{
char chaine [ N ] ;
int i ;
printf ( " Saisissez une phrase :\ n" ) ;

33
 fgets ( chaine , N , stdin ) ;
i = 0;
while ( chaine [ i ] != 0 )
i++;
i f ( i > 0 && chaine [ i −1] != ’\n ’ )
CLEAR_BUFFER ;
else
chaine [ i −1] = 0 ;
printf ( " Vous avez saisi :\ n%s\n" , chaine ) ;
i f ( chaine [ 0 ] >= ’A ’ && chaine [ 0 ] <= ’Z ’ )
printf ( " Cette phrase commence par une majuscule .\ n" ) ;
else
printf ( " Cette phrase ne commence pas par une majuscule .\ n" ) ;
i = 0;
while ( chaine [ i ] != 0 && chaine [ i ] != ’. ’ )
i++;
i f ( chaine [ i ] == ’. ’ )
i f ( chaine [ i +1] == 0 )
printf ( " Cette phrase se termine par un point .\ n" ) ;
else
printf ( " Vous avez saisi plus d ’une phrase .\ n" ) ;
else
printf ( " Cette phrase ne se termine pas par un point .\ n" ) ;
return 0 ;
}

34
1.8 Fonctions
1.8.1 Les procédures
Une procédure est un ensemble d’instructions portant un nom. Pour définir une procédure, on utilise la syntaxe :
void nomprocedure ( )
{
/∗
instructions
∗/
}

Une procédure est une nouvelle instruction, il suffit pour l’exécuter d’utiliser son nom. Par exemple, pour exécuter
(on dit aussi appeler ou invoquer) une procédure appelée pr, il suffit d’écrire pr();. Les deux programmes suivants
font la même chose. Le premier est écrit sans procédure :
#include<s t d i o . h>

i n t main ( )
{
printf ( " Bonjour \n" ) ;
return 0 ;
}

Et dans le deuxième, le printf est placé dans la procédure afficheBonjour et cette procédure est appelée depuis le
main.

#include<s t d i o . h>

void afficheBonjour ( )
{
printf ( " Bonjour \n" ) ;
}

i n t main ( )
{
afficheBonjour ( ) ;
return 0 ;
}

Vous pouvez définir autant de procédures que vous le voulez et vous pouvez appeler des procédures depuis des procé-
dures :
#include<s t d i o . h>

void afficheBonjour ( )
{
printf ( " Bonjour \n" ) ;
}

void afficheUn ( )
{
printf ( " 1\ n" ) ;
}

void afficheDeux ( )
{
printf ( " 2\ n" ) ;
}

35
void afficheUnEtDeux ( )
{
afficheUn ( ) ;
afficheDeux ( ) ;
}

void afficheAuRevoir ( )
{
printf ( " Au revoir \n" ) ;
}

i n t main ( )
{
afficheBonjour ( ) ;
afficheUnEtDeux ( ) ;
afficheAuRevoir ( ) ;
return 0 ;
}

Ce programme affiche :

Bonjour
1
2
Au revoir

Regardez bien le programme suivant et essayez de déterminer ce qu’il affiche.

#include<s t d i o . h>

void procedure1 ( )
{
printf ( " debut procedure 1\ n" ) ;
printf ( " fin procedure 1\ n" ) ;
}

void procedure2 ( )
{
printf ( " debut procedure 2\ n" ) ;
procedure1 ( ) ;
printf ( " fin procedure 2\ n" ) ;
}

void procedure3 ( )
{
printf ( " debut procedure 3\ n" ) ;
procedure1 ( ) ;
procedure2 ( ) ;
printf ( " fin procedure 3\ n" ) ;
}

i n t main ( )
{
printf ( " debut main \n" ) ;
procedure2 ( ) ;
procedure3 ( ) ;
printf ( " fin main \n" ) ;
return 0 ;
}

36
La réponse est
debut main
debut procedure 2
debut procedure 1
fin procedure 1
fin procedure 2
debut procedure 3
debut procedure 1
fin procedure 1
debut procedure 2
debut procedure 1
fin procedure 1
fin procedure 2
fin procedure 3
fin main
Vous remarquez au passage que main est aussi une procédure. main est exécutée automatiquement au lancement du
programme.

1.8.2 Variables locales

Une procédure est un bloc d’instructions et est sujette aux mêmes règles que main. Il donc possible de déclarer des
variables :
void nomprocedure ( )
{
/∗
d e c l a r a t i o n de v a r i a b l e s
∗/
/∗
instructions
∗/
}

Attention, ces variables ne sont accessibles que dans le corps de la procédure, cela signifie qu’elle naissent au moment
de leur déclaration et qu’elles sont détruites une fois la dernière instruction de la procédure exécutée. C’est pour cela
qu’on les apelle des variables locales. Une variable locale n’est visible qu’entre sa déclaration et l’accolade fermant
la procédure. Par exemple, ce code est illégal :
#include<s t d i o . h>

/∗
v o i d maProcedure ( )
{
char a = b ;
}

i n t main ( )
{
char b = ’ k ’ ;
p r i n t f ("%c , %c \n " , a , b ) ;
return 0;
}
∗/

En effet, la variable b est déclarée dans la procédure main, et n’est donc visible que dans cette même procédure. Son
utilisation dans maProcedure est donc impossible. De même, la variable a est déclarée dans maProcedure, elle n’est pas
visible dans le main. Voici un exemple d’utilisation de variables locales :

37
#include<s t d i o . h>

void unADix ( )
{
int i ;
f o r ( i = 1 ; i <= 10 ; i++ )
printf ( "%d\n" , i ) ;
}

i n t main ( )
{
unADix ( ) ;
return 0 ;
}

1.8.3 Passage de paramètres

Il est possible que la valeur d’une variable locale d’une procédure ne soit connue qu’au moment de l’appel de la
procédure. Considérons le programme suivant :
i n t main ( )
{
int i ;
printf ( " Veuillez saisir un entier : " ) ;
scanf ( ’’%d ’’ , &i ) ;
/∗
Appel d ’ une p r o c e d u r e a f f i c h a n t l a v a l e u r de i .
∗/
return 0 ;
}

Comment définir et invoquer une procédure afficheInt permettant d’afficher cet entier saisi par l’utilisateur ? Vous
conviendrez que la procédure suivante ne passera pas la compilation
void afficheInt ( )
{
printf ( ’’%d ’’ , i ) ;
}

En effet, la variable i est déclarée dans le main, elle n’est donc pas visible dans afficheInt. Pour y remédier, on définit
afficheInt de la sorte :

void afficheInt ( i n t i )
{
printf ( ’’%d ’’ , i ) ;
}

i est alors appelé un paramètre, il s’agit d’une variable dont la valeur sera précisée lors de l’appel de la procédure.
On peut aussi considérer que i est une valeur inconnue, et qu’elle est initialisée lors de l’invocation de la procédure.
Pour initialiser la valeur d’un paramètre, on place cette valeur entre les parenthèses lors de l’appel de la procédure,
par exemple : afficheInt(4) lance l’exécution de la procédure afficheInt en initialisant la valeur de i à 4. On dit aussi
que l’on passe en paramètre la valeur 4. La version correcte de notre programme est :
#include<s t d i o . h>

void afficheInt ( i n t i )
{
printf ( "%d" , i ) ;

38
}

i n t main ( )
{
int i ;
printf ( " Veuillez saisir un entier : " ) ;
scanf ( "%d" , &i ) ;
afficheInt ( i ) ;
printf ( "\n" ) ;
return 0 ;
}

Attention, notez bien que le i de afficheInt et le i du main sont deux variables différentes, la seule chose qui les
lie vient du fait que l’instruction afficheInt(i) initialise le i de afficheInt à la valeur du i du main. Il serait tout à
fait possible d’écrire :
#include<s t d i o . h>

void afficheInt ( i n t j )
{
printf ( "%d" , j ) ;
}

i n t main ( )
{
int i ;
printf ( " Veuillez saisir un entier : " ) ;
scanf ( "%d" , &i ) ;
afficheInt ( i ) ;
printf ( "\n" ) ;
return 0 ;
}

Dans cette nouvelle version, l’instruction afficheInt(i) initialise le j de afficheInt à la valeur du i du main.

Il est possible de passer plusieurs valeurs en paramètre. Par exemple, la procédure suivante affiche la somme des
deux valeurs passées en paramètre :
void afficheSomme ( i n t a , i n t b )
{
printf ( ’’%d ’’ , a + b ) ;
}

L’invocation d’une telle procédure se fait en initialisant les paramètres dans le même ordre et en séparant les valeurs
par des virgules, par exemple afficheSomme(3, 4) invoque afficheSomme en initialisant a à 3 et b à 4. Vous devez intialiser
tous les paramètres et vous devez placer les valeurs dans l’ordre. Récapitulons :
#include<s t d i o . h>

void afficheSomme ( i n t a , i n t b )
{
printf ( "%d" , a + b ) ;
}

i n t main ( )
{
int i , j ;
printf ( " Veuillez saisir deux entiers :\ na = " ) ;
scanf ( "%d" , &i ) ;
printf ( "b = " ) ;

39
 scanf ( "%d" , &j ) ;
printf ( "a + b = " ) ;
afficheSomme ( i , j ) ;
printf ( "\n" ) ;
return 0 ;
}

La procédure ci-avant s’exécute de la façon suivante :

Veuillez saisir deux entiers :
a = 3
b = 5
a + b = 8
Lors de l’appel afficheInt(r) de la procédure void afficheInt(int i), r est le paramètre effectif et i le paramètre
formel. Notez bien que i et r sont deux variables distinctes. Par exemple, qu’affiche le programme suivant ?
#include<s t d i o . h>

void incr ( i n t v )
{
v++;
}

i n t main ( )
{
int i ;
i = 6;
incr ( i ) ;
printf ( "%d\n" , i ) ;
return 0 ;
}

La variable v est initialisée à la valeur de i, mais i et v sont deux variables différentes. Modifier l’une n’affecte pas
l’autre.

1.8.4 Les fonctions

Le principe
Nous avons vu qu’un sous-programme appelant peut communiquer des valeurs au sous-programme appelé. Mais est-il
possible pour un sous-programme appelé de communiquer une valeur au sous-programme appelant ? La réponse est
oui. Une fonction est un sous-programme qui communique une valeur au sous-programme appelant. Cette valeur
s’appelle valeur de retour, ou valeur retournée.

Invocation
La syntaxe pour appeler une fonction est :
v = nomfonction ( parametres ) ;

L’instruction ci-dessus place dans la variable v la valeur retournée par la fonction nomfonction quand lui passe les
paramètres parametres. Nous allons plus loin dans ce cours définir une fonction carre qui retourne le carré de valeur
qui lui est passée en paramètre, alors l’instruction
v = carre ( 2 ) ;

placera dans v le carré de 2, à savoir 4. On définira aussi une fonction somme qui retourne la somme de ses paramètres,
on placera donc la valeur 2 + 3 dans v avec l’instruction
v = somme ( 2 , 3 ) ;

40
Définition
On définit une fonction avec la syntaxe suivante :
typeValeurDeRetour nomFonction ( listeParametres )
{
}

La fonction carre sera donc définie comme suit :

i n t carre ( i n t i )
{
/∗
instructions
∗/
}

Une fonction ressemble beaucoup à une procédure. Vous remarquez que void est remplacé par int, void signifie aucune
type de retour, une procédure est donc une fonction qui ne retourne rien. Un int est adapté pour représenter le carré
d’un autre int, j’ai donc choisi comme type de retour le type int. Nous définirons la fonction somme comme suit :
i n t somme ( i n t a , i n t b )
{
/∗
instructions
∗/
}

L’instruction servant à retourner une valeur est return. Cette instruction interrompt l’exécution de la fonction et
retourne la valeur placée immédiatement après. Par exemple, la fonction suivante retourne toujours la valeur 1.
i n t un ( )
{
return 1 ;
}

Lorsque l’on invoque cette fonction, par exemple

v = un ( ) ;

La valeur 1, qui est retournée par un est affectée à v. On définit une fonction qui retourne le successeur de son
paramètre :
i n t successeur ( i n t i )
{
return i + 1 ;
}

Cette fonction, si on lui passe la valeur 5 en paramètre, retourne 6. Par exemple, l’instruction
v = successeur ( 5 ) ;

affecte à v la valeur 6. Construisons maintenant nos deux fonctions :

i n t carre ( i n t i )
{
return i ∗ i ;
}

i n t somme ( i n t a , i n t b )
{
return a + b ;
}

41
Vous noterez qu’une fonction ne peut pas retourner un tableau, une fonction ne peut retourner que des valeurs
scalaires. Vous comprendrez pourquoi en étudiant les pointeurs.

1.8.5 Passages de paramètre par référence

En C, lorsque vous invoquez une fonction, toutes les valeurs des paramètres effectifs sont recopiés dans les paramètres
formels. On dit dans ce cas que le passage de paramètre se fait par valeur. Vous ne pouvez donc, a priori, communiquer
qu’une seule valeur au programme appelant. Effectivement :
— seule la valeur de retour vous permettra de commnuniquer une valeur au programme appelant.
— une fonction ne peut retourner que des valeurs scalaires.
Lorsque vous passez un tableau en paramètre, la valeur qui est recopiée dans le paramètre formel est l’adresse de ce
tableau (l’adresse est une valeur scalaire). Par conséquent toute modification effectuée sur les éléments d’un tableau
dont l’adresse est passée en paramètre par valeur sera repercutée sur le paramètre effectif (i.e. le tableau d’origine).
Lorsque les modifications faites sur un paramètre formel dans un sous-programme sont repércutées sur le paramètre
effectif, on a alors un passage de paramètre par référence. Nous retiendrons donc les trois règles d’or suivantes :
— Les variables scalaires se passent en paramètre par valeur
— Les variables non scalaires se passent en paramètre par référence
— Une fonction ne peut retourner que des valeurs scalaires

42
1.9 Structures
1.9.1 Définition
Nous avons utilisé des tableaux pour désigner, avec un nom unique, un ensemble de variables. Par exemple, un tableau
T à n éléments est un ensemble n de variables désignées par la lettre T . Dans un tableau, les variables doivent être de
type homogène, cela signifiant qu’il n’est pas possible de juxtaposer des char et des int dans un tableau. Lorsque l’on
souhaite faire cohabiter dans une variable non scalaire des types hétérogènes, on utilise des structures.
Une structure, appelé enregistrement dans d’autres langages, est une variable contenant plusieurs variables, appelées
champs. Si une structure t contient un char et un int, chacun de ces champs portera un nom, par exemple i et c.
Dans ce cas, t.c désignera le char de t et t.i l’int de t.

1.9.2 Déclaration
Pour créer un type structuré, on utilise la syntaxe suivante :

struct nomdutype
{
typechamp_1 nomchamp_1;
typechamp_2 nomchamp_2;
...
typechamp_n nomchamp_n;
};

On précise donc le nom de ce type structuré, et entre les accolades, la liste des champs avec pour chacun d’eux son
type. Vous remarquez que le nombre de champs est fixé d’avance. On n’accède pas à un champ avec un indice mais
avec un nom. Considérons par exemple le type structuré suivant :
struct point
{
double abs ;
double ord ;
};

Ce type permet de représenter un point dans R2 , avec respectivement uns abscisse et une ordonnée. struct point est
maintenant un type, il devient possible de déclarer un point p comme tout autre variable :
struct point p ;

1.9.3 Accès aux champs

On accède aux champs d’une variable structurée à l’aide de la notation pointée

[Link]

Ainsi, le champ ord de notre variable p sera accessible avec [Link] et le champ abs de notre variable p sera accessible
avec [Link]. Voici un exemple de programme illustrant ce principe :
#include<s t d i o . h>

struct point
{
double abs ;
double ord ;
};

main ( )

43
{
struct point p ;
p . ord = 2 ;
p . abs = p . ord + 1 ;
printf ( "p = (%f , %f)\n" , p . abs , p . ord ) ;
}

Ce programme affiche :

p = (3.000000, 2.000000)

Attention, l’opérateur d’accès au champ . est prioritaire sur tous les autres opérateurs unaires, binaires et ternaires !
Il faudra vous en rappeler quand on étudiera les listes chaînées.

1.9.4 Typedef

On se débarasse du mot clé struct en renommant le type, on utilisera par exemple la syntaxe suivante :
#include<s t d i o . h>

typedef struct point

{
double abs ;
double ord ;
} point ;

main ( )
{
point p ;
p . ord = 2 ;
p . abs = p . ord + 1 ;
printf ( "p = (%f , %f)\n" , p . abs , p . ord ) ;
}

point est donc le nom de ce type structuré.

1.9.5 Tableaux de structures

Rien de nous empêche de créer des tableaux de structures, par exemple :
#include<s t d i o . h>

#define N 10

typedef struct point

{
double abs ;
double ord ;
} point ;

main ( )
{
point p [ N ] ;
int i ;
p [ 0 ] . ord = 0 ;
p [ 0 ] . abs = 1 ;
f o r ( i = 1 ; i < N ; i++)
{

44
 p [ i ] . ord = p [ i − 1 ] . ord + 1 . ;
p [ i ] . abs = p [ i − 1 ] . abs + 2 . ;
}
f o r ( i = 0 ; i < N ; i++)
{
printf ( "p [% d] = (%f , %f)\n" , i , p [ i ] . abs , p [ i ] . ord ) ;
}
}

Ce programme affiche :

p[0] = (1.000000, 0.000000)

p[1] = (3.000000, 1.000000)
p[2] = (5.000000, 2.000000)
p[3] = (7.000000, 3.000000)
p[4] = (9.000000, 4.000000)
p[5] = (11.000000, 5.000000)
p[6] = (13.000000, 6.000000)
p[7] = (15.000000, 7.000000)
p[8] = (17.000000, 8.000000)
p[9] = (19.000000, 9.000000)

1.9.6 Structures et fonctions

Lorsqu’on les passe en paramètre, les structures se comportent comme des variables scalaires, cela signifie qu’on ne peut
les passer en paramètre que par valeur. Par contre, un tableau de structures est nécessairement passé en paramètre
par référence. Réecrivons le programme précédent avec des sous-programmes :
#include<s t d i o . h>

#define N 10

typedef struct point

{
double abs ;
double ord ;
} point ;

void initTableauPoints ( point p [ ] , i n t n )

{
int i ;
p [ 0 ] . ord = 0 ;
p [ 0 ] . abs = 1 ;
f o r ( i = 1 ; i < n ; i++)
{
p [ i ] . ord = p [ i − 1 ] . ord + 1 . ;
p [ i ] . abs = p [ i − 1 ] . abs + 2 . ;
}
}

void affichePoint ( point p )

{
printf ( " (%f , %f)" , p . abs , p . ord ) ;
}

void afficheTableauPoints ( point p [ ] , i n t n )

{
int i ;
f o r ( i = 0 ; i < n ; i++)

45
 {
printf ( "p [% d] = " , i ) ;
affichePoint ( p [ i ] ) ;
printf ( "\n" ) ;
}
}

main ( )
{
point p [ N ] ;
initTableauPoints ( p , N ) ;
afficheTableauPoints ( p , N ) ;
}

Comme une structure se comporte comme une variable scalaire, il est possible de retourner une structure dans une
fonction, il est donc possible de modifier le programme ci-avant de la sorte :
#include<s t d i o . h>

#define N 10

typedef struct point

{
double abs ;
double ord ;
} point ;

point nextPoint ( point previous )

{
point result ;
result . ord = previous . ord + 1 . ;
result . abs = previous . abs + 2 . ;
return result ;
}

void initTableauPoints ( point p [ ] , i n t n )

{
int i ;
p [ 0 ] . ord = 0 ;
p [ 0 ] . abs = 1 ;
f o r ( i = 1 ; i < n ; i++)
p [ i ] = nextPoint ( p [ i − 1 ] ) ;
}

void affichePoint ( point p )

{
printf ( " (%f , %f)" , p . abs , p . ord ) ;
}

void afficheTableauPoints ( point p [ ] , i n t n )

{
int i ;
f o r ( i = 0 ; i < n ; i++)
{
printf ( "p [% d] = " , i ) ;
affichePoint ( p [ i ] ) ;
printf ( "\n" ) ;
}
}

46
main ( )
{
point p [ N ] ;
initTableauPoints ( p , N ) ;
afficheTableauPoints ( p , N ) ;
}

47
1.10 Pointeurs
La notion de pointeur est très importante en C, elle va vous permettre de comprendre le fonctionnement d’un pro-
gramme, de programmer de façon davantage propre et performante, et surtout de concevoir des programmes que vous
ne pourriez pas mettre au point sans cela.

Une des premières choses à comprendre quand on programme, c’est qu’une variable est un emplacement de la mémoire
dans lequel vous allez placer une valeur. En programmant, vous utilisez son nom pour y lire ou écrire une valeur. Mais
ce qui se passe au coeur de la machine est quelque peu plus complexe, les noms que l’on donne aux variables servent
à masquer cette complexité.

Pour le compilateur, une variable est un emplacement dans la mémoire, cet emplacement est identifié par une adresse
mémoire. Une adresse est aussi une valeur, mais cette valeur sert seulement à spécifier un emplacement dans la mé-
moire. Lorsque vous utilisez le nom d’une variable, le compilateur le remplace par une adresse, et manipule la variable
en utilisant son adresse.

Ce système est ouvert, dans le sens où vous pouvez décider d’utiliser l’adresse d’une variable au lieu d’utiliser son
nom. Pour ce faire, on utilise des pointeurs.

1.10.1 Introduction
Un pointeur est une variable qui contient l’adresse mémoire d’une autre variable.

Déclaration
T ∗ est le type d’une variable contenant l’adresse mémoire d’une variable de type T . Si une variable p de type T ∗
contient l’adresse mémoire d’une variable x de type T , on dit alors que p pointe vers x (ou bien sur x). &x est
l’adresse mémoire de la variable x. Exposons cela dans un exemple,
#include<s t d i o . h>

i n t main ( )
{
int x = 3 ;
int ∗ p ;
p = &x ;
return 0 ;
}

x est de type int. p est de type int∗, c’est à dire de type pointeur de int, p est donc faite pour contenir l’adresse
mémoire d’un int. &x est l’adresse mémoire de la variable x, et l’affectation p = &x place l’adresse mémoire de x dans
le pointeur p. A partir de cette affectation, p pointe sur x.

Affichage
La chaîne de format d’une adresse mémoire est ”%X”. On affiche donc une adresse mémoire (très utile pour débugger :-)
comme dans l’exemple ci-dessous,
#include<s t d i o . h>

i n t main ( )
{
int x = 3 ;
int ∗ p ;
p = &x ;
printf ( "p contient la valeur %X , qui n ’est autre que l ’ adresse %X de x\n" ,
p , &x ) ;
return 0 ;

48
}

Accès à la variable pointée

Le lecteur impatient se demande probablement à quoi peuvent servir toutes ces étoiles ? Quel peut bien être l’intérêt
des pointeurs ?

Si p pointe sur x, alors il est possible d’accéder à la valeur de x en passant par p. Pour le compilateur, ∗p est la
variable pointée par p, cela signifie que l’on peut, pour le moment du moins, utiliser indifférement ∗p ou x. Ce sont
deux façons de se référer à la même variable, on appelle cela de l’aliasing. Explicitons cela sur un exemple,
#include<s t d i o . h>

i n t main ( )
{
int x = 3 ;
int ∗ p ;
p = &x ;
printf ( "x = %d\n" , x ) ;
∗p = 4 ;
printf ( "x = %d\n" , x ) ;
return 0 ;
}

L’affectation p = &x fait pointer p sur x. A partir de ce moment, ∗p peut être utilisé pour désigner la variable x. De
ce fait, l’affectation x = 4 peut aussi être écrite ∗p = 4. Toutes les modifications opérées sur ∗p seront répercutées sur
la variable pointée par p. Donc ce programme affiche

x = 3
x = 4

Récapitulons
Qu’affiche, à votre avis, le programe suivant ?
#include<s t d i o . h>

i n t main ( )
{
int x = 3 ;
int y = 5 ;
int ∗ p ;
p = &x ;
printf ( "x = %d\n" , x ) ;
∗p = 4 ;
printf ( "x = %d\n" , x ) ;
p = &y ;
printf ( "*p = %d\n" , ∗p ) ;
∗p = ∗p + 1 ;
printf ( "y = %d\n" , y ) ;
return 0 ;
}

x est initialisé à 3 et y est initialisé à 5. L’affectation p = &x fait pointer p sur x, donc ∗p et x sont deux écritures
différentes de la même variable. Le premier printf affiche la valeur de x : plus précisément x = 3. Ensuite, l’affectation
∗p = 4 place dans la valeur pointée par p, à savoir x, la valeur 4. Donc le deuxième printf affiche x = 4. L’affectation
p = &y fait maintenant pointer p sur y, donc la valeur de ∗p est la valeur de la variable pointée y. le troisième printf
affiche donc ∗p = 5. N’oubliez pas que comme p pointe sur y, alors ∗p et y sont deux alias pour la même variable, de

49
ce fait, l’instruction ∗p = ∗p + 1 peut tout à fait s’écrire y = y + 1. Cette instruction place donc dans y la valeur 6, le
quatrième printf affiche donc y = 6. Ce programme affiche donc :

x = 3
x = 4
*p = 5
y = 6

1.10.2 Tableaux
Il est possible d’aller plus loin dans l’utilisation des pointeurs en les employant pour manipuler des tableaux. Tout
d’abord, éclaircissons quelques points.

Démystification (et démythification) du tableau en C

Les éléments d’un tableau sont juxtaposés dans la mémoire. Autrement dit, ils sont placés les uns à coté des autres.
Sur le plan de l’adressage, cela a une conséquence fort intuitive. Sachant qu’un int occupe 2 octets en mémoire et que
&T [0] est l’adresse mémoire du premier élément du tableau T , quelle est l’adresse mémoire de T [1] ? La réponse est la
plus simple : &T [0] + 2 (ne l’écrivez jamais ainsi dans un programme, vous verrez pourquoi plus loin dans le cours...).
Cela signifie que si l’on connait l’adresse d’un élément d’un tableau (le premier en l’occurrence), il devient possible de
retrouver les adresses de tous les autres éléments de ce tableau.

J’ai par ailleurs, une assez mauvaise surprise pour vous. Vous utilisez sans le savoir des pointeurs depuis que vous
utilisez des tableaux. Etant donné la déclaration int T [50], vous conviendrez que les désignations {T [0], . . . , T [49]} per-
mettent de se référer aux 50 éléments du tableau T . Mais vous est-il déjà arrivé, en passant un tableau en paramètre,
d’écrire T sans écrire d’indice entre crochets ? Par exemple,
#include<s t d i o . h>

void initTab ( i n t K [ ] , i n t n )
{
int i ;
f o r ( i = 0 ; i < n ; i++)
K [ i ] = i + 1;
}

void afficheTab ( i n t K [ ] , i n t n )
{
int i ;
f o r ( i = 0 ; i < n ; i++)
printf ( "%d\n" , K [ i ] ) ;
}

i n t main ( )
{
int T [ 5 0 ] ;
initTab ( T , 5 0 ) ;
afficheTab ( T , 5 0 ) ;
return 0 ;
}

Vous remarquez que lorsque l’on passe un tableau en paramètre à un sous-programme, on mentionne seulement son
nom. En fait, le nom d’un tableau, T dans l’exemple ci-avant, est l’adresse mémoire du premier élément de ce
tableau. Donc, T est une variable contenant une adresse mémoire, T est par conséquent un pointeur. Lorsque dans un
sous-programme auquel on a passé un tableau en paramètre, on mentionne un indice, par exemple K[i], le compilateur
calcule l’adresse du i-ème élément de K pour lire ou écrire à cette adresse.

50
Utilisation des pointeurs
Commençons par observer l’exemple suivant :
#include<s t d i o . h>

i n t main ( )
{
char t [ 1 0 ] ;
char∗ p ;
t [ 0 ] = ’a ’ ;
p = t;
printf ( " le premier element du tableau est %c .\ n" , ∗p ) ;
return 0 ;
}

La variable t contient l’adresse mémoire du premier élément du tableau t. p est un pointeur de char, donc l’affectation
p = t place dans p l’adresse mémoire du premier élément du tableau t. Comme p pointe vers t[0], on peut indifférement
utiliser ∗p ou t[0]. Donc ce programme affiche

le premier element du tableau est a.

Calcul des adresses mémoire

Tout d’abord, je tiens à rappeler qu’une variable de type char occupe un octet en mémoire. Considérons maintenant
les déclarations

char t[10] ;
et

char ∗ p = t ;
Nous savons que si p pointe vers t[0], il est donc aisé d’accéder au premier élément de t en utilisant le pointeur p.
Mais comment accéder aux autres éléments de t ? Par exemple T [1] ? Souvenez-vous que les éléments d’un tableau sont
juxtaposés, dans l’ordre, dans la mémoire. Par conséquent, si p est l’adresse mémoire du premier élément du tableau t,
alors (p+1) est l’adresse mémoire du deuxième élément de ce tableau. Vous êtes conviendrez que ∗p est la variable dont
l’adresse mémoire est contenue dans p. Il est possible, plus généralement, d’écrire ∗(p + 1) pour désigner la variable
dont l’adresse mémoire est (p + 1), c’est à dire (la valeur contenue dans p) + 1. Illustrons cela dans un exemple, le
programme
#include<s t d i o . h>

i n t main ( )
{
char t [ 1 0 ] ;
char∗ p ;
t [ 1 ] = ’b ’ ;
p = t;
printf ( " le deuxieme element du tableau est %c .\ n" , ∗ ( p+1) ) ;
return 0 ;
}

affiche

le deuxième element du tableau est b.

En effet, p + 1 est l’adresse mémoire du deuxième élément de t, il est donc possible d’utiliser indifférement ∗(p + 1) et
t[1]. Plus généralement, on peut utiliser ∗(p + i) à la place de t[i]. En effet, (p + i) est l’adresse du i-ème élément de t,
et ∗(p + i) est la variable dont l’adresse mémoire est (p + i). Par exemple,

51
#include<s t d i o . h>
#define N 26

i n t main ( )
{
char t [ N ] ;
char v = ’A ’ ;
char∗ p ;
int i ;
p = t;

/∗ i n i t i a l i s a t i o n du t a b l e a u ∗/
f o r ( i = 0 ; i < N ; i++)
∗ ( p + i ) = v++;

/∗ a f f i c h a g e du t a b l e a u ∗/
f o r ( i = 0 ; i < N ; i++)
printf ( "%c " , ∗ ( p + i ) ) ;

printf ( "\n" ) ;
return 0 ;
}

Ou encore, en utilisant des sous-programmes,

#include<s t d i o . h>
#define N 26

void initTab ( char∗ k , i n t n )

{
int i ;
i n t v = ’A ’ ;
f o r ( i = 0 ; i < n ; i++, k++, v++)
∗k = v ;
}

void afficheTab ( char∗ k , i n t n )

{
int i ;
f o r ( i = 0 ; i < n ; i++, k++)
printf ( "%c " , ∗k ) ;
printf ( "\n" ) ;
}

i n t main ( )
{
char t [ N ] ;
initTab ( t , N ) ;
afficheTab ( t , N ) ;
return 0 ;
}

Ces deux sous-programmes affichent

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Arithmétique des pointeurs

Supposons que le tableau t contienne des int, sachant qu’un int occupe 2 octets en mémoire. Est-ce que (t + 1) est
l’adresse du deuxième élément de t ?

52
Mathématiquement, la réponse est non, l’adresse du deuxième élément est t + (la taille d0 un int) = (t + 2). Etant
donné un tableau p d’éléments occupant chacun n octets en mémoire, l’adresse du i-ème élément est alors p + i × n.

Cependant, la pondération systématique de l’indice par la taille occupée en mémoire par chaque élément est d’une
part une lourdeur dont on se passerait volontier, et d’autre part une source d’erreurs et de bugs. Pour y remédier,
le compilateur prend cette partie du travail en charge,on ne pondérera donc pas les indices ! Cela signifie, plus
explicitement, que quel que soit le type des éléments du tableau p, l’adresse mémoire du i-ème élément de p est p + i.
On le vérifie expérimentalement en exécutant le programme suivant :
#include<s t d i o . h>
#define N 30

void initTab ( i n t ∗ k , i n t n )
{
int i ;
∗k = 1 ;
f o r ( i = 1 , k++ ; i < n ; i++, k++)
∗k = ∗ ( k − 1 ) + 1 ;
}

void afficheTab ( i n t ∗ k , i n t n )
{
int i ;
f o r ( i = 0 ; i < n ; i++, k++)
printf ( "%d " , ∗k ) ;
printf ( "\n" ) ;
}

i n t main ( )
{
int t [ N ] ;
initTab ( t , N ) ;
afficheTab ( t , N ) ;
return 0 ;
}

1.10.3 Allocation dynamique de la mémoire

La lecture du chapitre précédent, si vous y avez survécu, vous a probablement mené à une question que les élèves
posent souvent : ”Monsieur pourquoi on fait ça ?”. C’est vrai ! Pourquoi on manipulerait les tableaux avec des poin-
teurs alors que dans les exemples que je vous ai donné, on peut le faire sans les pointeurs ? Dans la mesure où un
tableau est un pointeur, on peut, même à l’intérieur d’un sous-programme auquel un tableau a été passé en paramètre,
manipuler ce tableau avec des crochets. Alors dans quel cas utiliserons-nous des pointeurs pour parcourir les tableaux ?

De la même façon qu’il existe des cas dans lesquels on connait l’adresse d’une variable scalaire mais pas son nom,
il existe des tableaux dont on connait l’adresse mais pas le nom.

Un problème de taille
Lorsque l’on déclare un tableau, il est obligatoire de préciser sa taille. Cela signifie que la taille d’un tableau doit
être connue à la compilation. Alors que faire si on ne connait pas cette taille ? La seule solution qui se présente pour
le moment est le surdimensionnement, on donne au tableau une taille très (trop) élevée de sorte qu’aucun débordement
ne se produise.

Nous aimerions procéder autrement, c’est à dire préciser la dimension du tableau au moment de l’exécu-
tion. Nous allons pour cela rappeler quelques principes. Lors de la déclaration d’un tableau t, un espace mémoire

53
alloué au stockage de la variable t, c’est à dire la variable qui contient l’adresse mémoire du premier élément du
tableau. Et un autre espace mémoire est alloué au stockage des éléments du tableau. Il y a donc deux zones mémoires
utilisées.

La fonction malloc
Lorsque vous déclarez un pointeur p, vous allouez un espace mémoire pour y stocker l’adresse mémoire d’un entier.
Et p, jusqu’à ce qu’on l’initialise, contient n’importe quoi. Vous pouvez ensuite faire pointer p sur l’adresse mémoire
que vous voulez (choisissez de préférence une zone contenant un int...). Soit cette adresse est celle d’une variable qui
existe déjà. Soit cette adresse est celle d’un espace mémoire créée spécialement pour l’occasion.

Vous pouvez demander au système d’exploitation de l’espace mémoire pour y stocker des valeurs. La fonction qui
permet de réserver n octets est malloc(n). Si vous écrivez malloc(10), l’OS réserve 10 octets, cela s’appelle une al-
location dynamique, c’est à dire une allocation de la mémoire au cours de l’exécution. Si vous voulez réserver de
l’espace mémoire pour stocker un int par exemple, il suffit d’appeler malloc(2), car un int occupe 2 octets en mémoire.

En même temps, c’est bien joli de réserver de l’espace mémoire, mais ça ne sert pas à grand chose si on ne sait
pas où il se trouve ! C’est pour ça que malloc est une fonction. malloc retourne l’adresse mémoire du premier octet de
la zone réservée. Par conséquent, si vous voulez créer un int, il convient d’exécuter l’instruction : p = malloc(2) où
p est de type int∗. Le malloc réserve deux octets, et retourne l’adresse mémoire de la zone allouée. Cette affectation
place donc dans p l’adresse mémoire du int nouvellement créé.

Cependant, l’instruction p = malloc(2) ne peut pas passer la compilation. Le compilateur vous dira que les types
void∗ et int∗ sont incompatibles (incompatible types in assignement). Pour votre culture générale, void∗ est le
type ”adresse mémoire” en C. Alors que int∗ est le type ”adresse mémoire d’un int”. Il faut donc dire au compilateur
que vous savez ce que vous faites, et que vous êtes sûr que c’est bien un int que vous allez mettre dans la variable
pointée. Pour ce faire, il convient d’effctuer ce que l’on appelle un cast, en ajoutant, juste après l’opérateur d’affecta-
tion, le type de la variable se situant à gauche de l’affectation entre parenthèses. Dans l’exemple ci-avant, cela donne :
int ∗ p = (int∗)malloc(2).

Voici un exemple illustrant l’utilisation de malloc.

#include<s t d i o . h>
#include<s t d l i b . h>

i n t main ( )
{
int ∗ p ;
p = ( i n t ∗ ) malloc ( s i z e o f ( i n t ) ) ;
∗p = 2 8 ;
printf ( "%d\n" , ∗p ) ;
return 0 ;
}

Vous remarquez que nous sommes bien dans un cas où l’on connait l’adresse d’une variable mais pas son nom. Le seul
moyen de manier la variable allouée dynamiquement est d’utiliser un pointeur.

La fonction f ree
Lorsque que l’on effectue une allocation dynamique, l’espace réservé ne peut pas être alloué pour une autre variable.
Une fois que vous n’en avez plus besoin, vous devez le libérer explicitement si vous souhaitez qu’une autre variable
puisse y être stockée. La fonction de libération de la mémoire est f ree. f ree(v) où v est une variable contenant l’adresse
mémoire de la zone à libérer. A chaque fois que vous allouez une zone mémoire, vous devez la libérer ! Un exemple
classique d’utilisation est :
#include<s t d i o . h>
#include<s t d l i b . h>

54
i n t main ( )
{
int ∗ p ;
p = ( i n t ∗ ) malloc ( s i z e o f ( i n t ) ) ;
∗p = 2 8 ;
printf ( "%d\n" , ∗p ) ;
free ( p ) ;
return 0 ;
}

Notez bien que la variable p, qui a été allouée au début du main, a été libéré par le f ree(p).

La valeur N U LL
La pointeur p qui ne pointe aucune adresse a la valeur N U LL. Attention, il n’est pas nécessairement initialisé à N U LL,
N U LL est la valeur que, conventionnellement, on décide de donner à p s’il ne pointe sur aucune zone mémoire valide.
Par exemple, la fonction malloc retourne N U LL si aucune zone mémoire adéquate n’est trouvée. Il convient, à chaque
malloc, de vérifier si la valeur retournée par malloc est différente de N U LL. Par exemple,
#include<s t d i o . h>
#include<s t d l i b . h>

i n t main ( )
{
int ∗ p ;
p = ( i n t ∗ ) malloc ( s i z e o f ( i n t ) ) ;
i f ( p == NULL )
exit ( 0 ) ;
∗p = 2 8 ;
printf ( "%d\n" , ∗p ) ;
free ( p ) ;
return 0 ;
}

Vous remarquez que le test de non nullité de la valeur retournée par malloc est effectué immédiatement après l’allocation
dynamique. Vous ne devez jamais utiliser un pointeur sans avoir vérifié sa validité, autrement dit, sa non-nullité. Un
pointeur contenant une adresse non valide est appelé un pointeur fou. Vous devrez, dans votre vie de programmeur,
les traquer avec hargne !

L’allocation dynamique d’un tableau

Lors de l’allocation dynamique d’un tableau, il est nécessaire de déterminer la taille mémoire de la zone de la zone
à occuper. Par exemple, si vous souhaitez allouer dynamiquament un tableau de 10 variables de type char. Il suf-
fit d’exécuter l’instruction malloc(10), car un tableau de 10 char occupe 10 octets en mémoire. Si par contre, vous
souhaitez allouer dynamiquement un tableau de 10 int, il conviendra d’exécuter malloc(20), car chaque int occupe 2
octets en mémoire.

Pour se simplifier la vie, le compilateur met à notre disposition la fonction sizeof , qui nous permet de calculer la
place prise en mémoire par la variable d’un type donné. Par exemple, soit T un type, la valeur sizeof (T ) est la taille
prise en mémoire par une variable de type T . Si par exemple on souhaite allouer dynamiquement un int, il convient
d’exécuter l’instruction malloc(sizeof (int)). Attention, sizeof prend en paramètre un type !

Si on souhaite allouer dynamiquement un tableau de n variables de type T , on exécute l’instruction malloc(n ∗

sizeof (T )). Par exemple, pour allouer un tableau de 10 int, on exécute malloc(10 ∗ sizeof (int)). Voici une variante
du programme d’un programme précédent :
#include<s t d i o . h>
#include<s t d l i b . h>
#define N 26

55
char∗ initTab ( i n t n )
{
char∗ k ;
int i ;
char value = ’a ’ ;
k = ( char ∗ ) malloc ( n∗ s i z e o f ( char ) ) ;
i f ( k == NULL )
return NULL ;
f o r ( i = 0 ; i < n ; i++, value++)
∗ ( k + i ) = value ;
return k ;
}

void afficheTab ( char∗ k , i n t n )

{
int i ;
f o r ( i = 0 ; i < n ; i++, k++)
printf ( "%c " , ∗k ) ;
printf ( "\n" ) ;
}

i n t main ( )
{
char∗ p = initTab ( N ) ;
i f ( p == NULL )
return −1;
afficheTab ( p , N ) ;
free ( p ) ;
return 0 ;
}

1.10.4 Passage de paramètres par référence

J’ai dit tout à l’heure : ”Pour le compilateur, ∗p est la variable pointée par p, cela signifie que l’on peut, pour le
moment du moins, utiliser indifférement ∗p ou x”. En précisant ”pour le moment du moins”, j’avais déjà l’intention de
vous montrer des cas dans lesquels ce n’était pas possible. C’est à dire des cas dans lesquels on connait l’adresse d’une
variable mais pas son nom.

Permutation de deux variables

A titre de rappel, observez attentivement le programme suivant :
#include<s t d i o . h>

void echange ( i n t ∗ x , i n t ∗ y )
{
i n t t = ∗x ;
∗x = ∗y ;
∗y = t ;
}

i n t main ( )
{
int a = 1 ;
int b = 2 ;
printf ( "a = %d , b = %d\n" , a , b ) ;
echange(&a , &b ) ;
printf ( "a = %d , b = %d\n" , a , b ) ;

56
 return 0 ;
}

A votre avis, affiche-t-il

a = 1, b = 2
a = 2, b = 1

ou bien

a = 1, b = 2
a = 1, b = 2

Méditons quelque peu : la question que l’on se pose est ”Est-ce que le sous-programme echange échange bien les valeurs
des deux variables a et b” ? Il va de soi qu’il échange bien les valeurs des deux variables x et y, mais comme ces deux
variables ne sont que des copies de a et b, cette permutation n’a aucun effet sur a et b. Cela signifie que la fonction
echange ne fait rien, on aurait pu écrire à la place un sous-programme ne contenant aucune instruction, l’effet aurait
été le même. Ce programme affiche donc

a = 1, b = 2
a = 1, b = 2

Remarques
Ceux dont la mémoire n’a pas été réinitialisé pendant les vacances se souviennent certainement du fait qu’il était
impossible de passer en paramètre des variables scalaires par référence. J’ai menti, il existe un moyen de passer des
paramètres par référence, et vous aviez des indices vous permettant de vous en douter ! Par exemple, l’instruction
scanf (”%d”, &x) permet de placer une valeur saisie par l’utilisateur dans x, et scanf est un sous-programme... Vous
conviendrez donc que la variable x a été passée en paramètre par référence. Autrement dit, que la valeur
de x est modifiée dans le sous-programme scanf , donc que la variable permettant de désigner x dans le corps de ce
sous-programme n’est pas une copie de x, mais la variable x elle-même, ou plutôt un alias de la variable x.

Vous pouvez d’ores et déjà retenir que

nomsousprogramme(. . . , &x, . . .)

sert à passer en paramètre la variable x par référence. Et finalement, c’est plutôt logique, l’instruction

nomsousprogramme(. . . , x, . . .)

passe en paramètre la valeur de x, alors que

nomsousprogramme(. . . , &x, . . .)

passe en paramètre l’adresse de x, c’est-à-dire un moyen de retrouver la variable x depuis le sous-programme et de

modifier sa valeur.

Cependant, si vous écrivez echange(&a, &b), le programme ne compilera pas... En effet, le sous-programme echange
prend en paramètre des int et si vous lui envoyez des adresses mémoire à la place, le compilateur ne peut pas ”compren-
dre” ce que vous voulez faire... Vous allez donc devoir modifier le sous-programme echange si vous voulez lui passer
des adresses mémoire en paramètre.

Utilisation de pointeurs
On arrive à la question suivante : dans quel type de variable puis-je mettre l’adresse mémoire d’une variable de type
entier ? La réponse est int∗, un pointeur sur int. Observons le sous-programme suivant,

57
void echange ( i n t ∗ x , i n t ∗ y )
{
i n t t = ∗x ;
∗x = ∗y ;
∗y = t ;
}

x et y ne sont pas des int, mais des pointeurs sur int. De ce fait le passage en paramètre des deux adresses &a et &b
fait pointer x sur a et y sur b. Donc ∗x est un alias de a et ∗y est un alias de b. Nous sommes, comme décrit dans
l’introduction de ce chapitre dans un cas dans lequel on connait l’adresse d’une variable, mais pas son nom : dans
le sous-programme echange, la variable a est inconnue (si vous l’écrivez, ça ne compilera pas...), seul le pointeur ∗x
permet d’accéder à la variable a.

Il suffit donc, pour écrire un sous-programme prenant en paramètre des variables passées par référence, de les dé-
clarer comme des pointeurs, et d’ajouter une ∗ devant à chaque utilisation.

1.10.5 Pointeurs sur fonction

58
1.11 Fichiers
1.11.1 Définitions
Supposons que l’on dispose d’un programme permettant saisir 10 entiers dans un tableau.
#include<s t d i o . h>

i n t main ( )
{
int t [ 1 0 ] , i ;
f o r ( i = 0 ; i < 10 ; i++)
{
printf ( " Saisir un entier : " ) ;
scanf ( "%d" , t + i ) ;
}
f o r ( i = 0 ; i < 10 ; i++)
printf ( "%d " , t [ i ] ) ;
printf ( "\n" ) ;
return 0 ;
}

Le problème qui se pose est que lorsque l’on sort de ce programme, les données saisies sont perdues. Si l’on souhaite
les avoir à disposition pour d’une exécution ultérieure, il convient d’utiler une mémoire persistante, c’est-à-dire qui
conserve les données entre deux exécutions. On utilise pour ce faire un fichier. Un fichier est une mémoire stockée de
façon permanente sur un disque et à laquelle on accède avec un nom. Les données dans un fichier se présentent de
façon séquentielle, et donc se lisent ou s’écrivent du début vers la fin.
Nous survolerons dans ce cours un ensemble de fonctions de stdio.h permettant de manier des fichiers. Pour plus
détails, il est très hautement recommandé de se reporter à la documentation.

1.11.2 Ouverture et fermeture

Pour accéder au contenu d’un fichier en lecture ou en écriture, on utilise les deux fonctions fopen et fclose.

La fonction fopen
fopen permet, comme son nom l’indique, d’ouvrir un fichier. Son prototype est FILE ∗fopen(const char ∗path, const
char ∗mode) :
— path est une chaîne de caractère contenant le chemin (relatif ou absolu) et le nom du fichier. Si le fichier est
dans le répertoire dans lequel s’exécute le programme, alors le nom du fichier suffit.
— mode est une chaîne de caractère contenant "r" pour ouvrir le fichier en mode lecture, "w" en mode écriture, etc.
— FILE∗ est un type permettant de référencer un fichier ouvert, fopen retourne NULL s’il est impossible d’ouvrir le
fichier (par exemple si le nom est incorrect). La valeur retournée devra être placée dans une variable de type
FILE∗, c’est cette valeur qui permettra par la suite d’accéder au contenu du fichier.

La fonction fclose
fclose sert à fermer un fichier. Son prototype est int fclose(FILE ∗fp) :
— fp est la variable de type FILE∗ permettant de référencer le fichier à fermer.
— Cette fonction retourne 0 si la fermeture s’est bien passée. Dans le cas contraire, des indications sur l’erreur
survenue sont accessibles dans des variables globales.

Utilisation
Si l’on souhaite par exemple lire dans un fichier s’appelant "[Link]" :
#include<s t d i o . h>

i n t main ( )

59
{
FILE ∗ f ;
f = fopen ( " toto . txt " , "r" ) ;
i f ( f == NULL )
{
printf ( " Erreur lors de l ’ ouverture du fichier toto . txt \n" ) ;
return −1;
}
/∗
L e c t u r e dans l e f i c h i e r
...
∗/
i f ( fclose ( f ) )
{
printf ( " Erreur lors de la fermeture du fichier toto . txt \n" ) ;
return −1;
}
return 0 ;
}

1.11.3 Lecture et écriture

Il existe plusieurs façons de lire dans un fichier : caractère par caractère, ligne par ligne, par paquets de caractères,
etc. Chaque lecture se faisant à l’aide d’une fonction appropriée. Lors d’un traitement se faisant à partir d’une lecture
dans un fichier, on appelle de façon itérée une fonction de lecture faisant avancer un curseur dans un fichier jusqu’à ce
que la fin du fichier soit atteinte.
L’écriture fonctionne de façon analogue, à un détail près : il est inutile d’écrire le caractère de fin de fichier, il est
ajouté automatiquement lors du fclose.

Caractère par caractère

La fonction int fgetc(FILE∗ stream) retourne un caractère lu dans le fichier f. Bien que le caractère lu soit un octet,
il est retourné dans un int. Le caractère EOF indique que la fin du fichier a été atteinte. Par exemple,
#include<s t d i o . h>

i n t main ( )
{
FILE ∗ f ;
char c ;
f = fopen ( " toto . txt " , "r" ) ;
i f ( f == NULL )
{
printf ( " Erreur lors de l ’ ouverture du fichier toto . txt \n" ) ;
return −1;
}
while ( ( c = fgetc ( f ) ) != EOF )
printf ( " caractere lu : %c\n" , c ) ;
i f ( fclose ( f ) )
{
printf ( " Erreur lors de la fermeture du fichier toto . txt \n" ) ;
return −1;
}
return 0 ;
}

On écrit un caractère dans un fichier à l’aide de la fonction int fputc(int c, FILE∗ stream).
#include<s t d i o . h>

60
i n t main ( )
{
FILE ∗ f ;
char c [ 8 ] = " Toto !\ n" ;
int i ;
f = fopen ( " toto . txt " , "w" ) ;
i f ( f == NULL )
{
printf ( " Erreur lors de l ’ ouverture du fichier toto . txt \n" ) ;
return −1;
}
f o r ( i = 0 ; i < 7 ; i++)
fputc ( c [ i ] , f ) ;
i f ( fclose ( f ) )
{
printf ( " Erreur lors de la fermeture du fichier toto . txt \n" ) ;
return −2;
}
return 0 ;
}

Par chaînes de caractères

Les deux fonctions char ∗fgets(char ∗s, int size, FILE ∗stream) et int fputs(const char ∗s, FILE ∗stream) permettent
de lire et d’écrire des chaînes de caractères dans des fichiers, voir la documentation pour plus de détails.

Par paquets
Les deux fonctions size\_t fread(void ∗ptr, size\_t size, size\_t nmemb, FILE ∗stream) et size\_t fwrite(const
void ∗ptr, size\_t size, size\_t nmemb, FILE ∗stream) sont très utiles lorsque l’on veut sauvegarder un tableau dans un
fichier, ou recopier un fichier dans un tableau (voir la documentation pour plus de détails). Voici tout de même deux
exemples :
#include<s t r i n g . h>
#include<s t d i o . h>

struct personne
{
char nom [ 3 0 ] ;
i n t age ;
};

i n t main ( i n t argv , char ∗∗ argc )

{
FILE ∗ f ;
struct personne repertoire [ 4 ] =
{{ " tata " , 2 } , {" toto " , 8 } , {" titi " , −1} , {" tutu " , 9 } } ;
f = fopen ( " toto . txt " , "w" ) ;
i f ( f == NULL )
{
printf ( " Impossible d ’ ouvrir le fichier toto . txt " ) ;
return −1;
}
fwrite ( repertoire , 4 , s i z e o f ( struct personne ) , f ) ;
i f ( fclose ( f ) )
{
printf ( " Impossible de fermer le fichier toto . txt " ) ;
return −2;

61
 }
return 0 ;
}

#include<s t r i n g . h>
#include<s t d i o . h>

struct personne
{
char nom [ 3 0 ] ;
i n t age ;
};

i n t main ( i n t argv , char ∗∗ argc )

{
FILE ∗ f ;
int i , n = 0 ;
struct personne repertoire [ 4 ] ;
f = fopen ( " toto . txt " , "r" ) ;
i f ( f == NULL )
{
printf ( " Impossible d ’ ouvrir le fichier toto . txt .\ n" ) ;
return −1;
}
while ( fread ( repertoire + n , 1 , s i z e o f ( struct personne ) , f ) )
n++;
f o r ( i = 0 ; i < n ; i++)
printf ( "%s %d\n" , repertoire [ i ] . nom , repertoire [ i ] . age ) ;
i f ( fclose ( f ) )
{
printf ( " Impossible de fermer le fichier toto . txt .\ n" ) ;
return −2;
}
return 0 ;
}

62
1.12 Listes Chaînées
1.12.1 Le problème
Plusieurs problèmes surviennent lorsque l’on utilise des tableaux pour stocker des valeurs :
— En cas de redimensionnement, il faut refaire une allocation dynamique et recopier tout le tableau.
— En cas d’insertion ou de suppression d’un élément, il faut décaler vers la gauche ou vers la droite tous les
successeurs.
— Concaténer ou fusionner des tableaux est une opération lourde au niveau mémoire.
— Tous les éléments doivent être stockés dans des zones contigües, l’allocation est donc un lourd travail lorsque la
mémoire est fragmentée.
— Bref, de nombreuses opérations sont lourdes en temps d’exécution.
Nous définirons dans ce cours un autre moyen de stocker les données en formant un ensemble ordonné, le listes chaînées.

1.12.2 Pointeurs et structures

Soit T un type structuré défini comme suit :
typedef struct T
{
int i ;
char c ;
}T ;

Si p est un pointeur de type T ∗, alors p contient l’adresse mémoire d’un élément de type T . Soit t une variable de type T ,
et soit l’affectation p = &t. Alors, p pointe sur t. De ce fait ∗p et t sont des alias, et nous pourrons indifférement utiliser
t.i (resp. t.c) et (∗p).i (resp (∗p).c). Par exemple, réecrivons le programme de l’exemple du cours sur les structures :
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct point

{
double abs ;
double ord ;
} point ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

point nextPoint ( point ∗ previous )

{
point result ;
result . ord = ( ∗ previous ) . ord + 1 . ;
result . abs = ( ∗ previous ) . abs + 2 . ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void initTableauPoints ( point ∗ p , i n t n )

{
int i ;
( ∗ p ) . ord = 0 ;
( ∗ p ) . abs = 1 ;
f o r ( i = 1 ; i < n ; i++)

63
 ∗ ( p + i ) = nextPoint ( p + i − 1 ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void affichePoint ( point ∗ p )

{
printf ( " (%f , %f)" , ( ∗ p ) . abs , ( ∗ p ) . ord ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void afficheTableauPoints ( point ∗ p , i n t n )

{
int i ;
f o r ( i = 1 ; i < n ; i++)
{
printf ( "p [% d] = " , i ) ;
affichePoint ( p + i ) ;
printf ( "\n" ) ;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
point ∗ p ;
p = ( point ∗ ) malloc ( N ∗ s i z e o f ( point ) ) ;
i f ( p == NULL )
return −1;
initTableauPoints ( p , N ) ;
afficheTableauPoints ( p , N ) ;
free ( p ) ;
return 0 ;
}

L’écriture (∗p).i permet de désigner le champ i de la variable pointée par p. Cette écriture, peu commode, peut être
remplacée par p− > i, par exemple :
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct point

{
double abs ;
double ord ;
} point ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

point nextPoint ( point ∗ previous )

{
point result ;
result . ord = previous−>ord + 1 . ;
result . abs = previous−>abs + 2 . ;

64
 return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void initTableauPoints ( point ∗ p , i n t n )

{
int i ;
p−>ord = 0 ;
p−>abs = 1 ;
f o r ( i = 1 ; i < n ; i++)
∗ ( p + i ) = nextPoint ( p + i − 1 ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void affichePoint ( point ∗ p )

{
printf ( " (%f , %f)" , p−>abs , p−>ord ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void afficheTableauPoints ( point ∗ p , i n t n )

{
int i ;
f o r ( i = 1 ; i < n ; i++)
{
printf ( "p [% d] = " , i ) ;
affichePoint ( p + i ) ;
printf ( "\n" ) ;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

main ( )
{
point ∗ p ;
p = ( point ∗ ) malloc ( N ∗ s i z e o f ( point ) ) ;
i f ( p == NULL )
return −1;
initTableauPoints ( p , N ) ;
afficheTableauPoints ( p , N ) ;
free ( p ) ;
}

Attention ! Les opérateurs d’accès aux champs . et −> ont une priorité supérieure à celles de tous les autres opérateurs
du langage ! Si vous manipulez un tableau de structures t et que vous souhaitez accéder au champ t du i-ème élément,
est-il intelligent d’écrire ∗(i + t).c ? Absolument pas ! . est prioritaire sur ∗, donc le parenthèsage implicite est ∗((
i + t).c), essayez de vous représenter ce que cela fait, et vous comprendrez pourquoi votre programme plante ! En
écrivant (i + t)−>c, vous obtenez une expression équivalente à (∗(i + t)).c, qui est déjà bien plus proche de ce que
l’on souhaite faire.

1.12.3 Un premier exemple

Considérons le type suivant :
typedef struct maillon

65
{
i n t data ;
struct maillon ∗ next ;
} maillon ;

On appelle cette forme de type un type récursif, c’est-à-dire qui contient un pointeur vers un élément du même type.
Observons l’exemple suivant :
#include<s t d i o . h>

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;
struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon m , p ;
maillon ∗ ptr ;
m . data = 1 ;
m . next = &p ;
p . data = 2 ;
p . next = NULL ;
f o r ( ptr = &m ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
return 0 ;
}

m et p sont deux maillons, et m−>next pointe vers p, cela signifie que lorsque l’on initialise ptr à &m, alors ptr pointe
sur m. Donc, lors de la première itération de la boucle for, la valeur prt−>data est [Link], à savoir 1. Lorsque le pas
de la boucle est exécuté, ptr reçoit la valeur ptr−>next, qui n’est autre que m−>next, ou encore &p. Donc ptr pointe
maintenant sur p. Dans la deuxième itération de la boucle, ptr−>data est la valeur [Link], à savoir 2. Ensuite le pas
de la boucle est exécuté, et ptr prend la valeur ptr−>next, à savoir p−>next, ou encore NULL. Comme ptr == NULL,
alors la boucle s’arrête. Ce programme affiche donc :

data = 1
data = 2

1.12.4 Le chaînage
La façon de renseigner les valeurs des pointeurs next observée dans l’exemple précédent s’appelle le chaînage. Une
liste de structures telle que chaque variable structurée contienne un pointeur vers vers une autre variable du même
type s’appelle une liste chaînée. Utilisons un tableau pour stocker les éléments d’une liste chaînée à 10 éléments.
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;
struct maillon ∗ next ;

66
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void printData ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon ∗ l ;
int i ;
l = ( maillon ∗ ) malloc ( N ∗ s i z e o f ( maillon ) ) ;
i f ( l == NULL )
return −1;
l−>data = 0 ;
f o r ( i = 1 ; i < N ; i++)
{
( l + i )−>data = i ;
( l + i − 1 )−>next = l + i ;
}
( l + N − 1 )−>next = NULL ;
printData ( l ) ;
free ( l ) ;
return 0 ;
}

Les 10 maillons de la liste chaînée ont été placés dans le tableau l, la première boucle dispose le chaînage des éléments
dans le même ordre que dans le tableau, l’affichage de la liste est fait dans le sous-programme printfData, et seul le
chaînage y est utilisé. Comme le champ data du i-ème élément de la liste contient la valeur i, alors ce programme
affiche :

data = 0
data = 1
data = 2
data = 3
data = 4
data = 5
data = 6
data = 7
data = 8
data = 9

Pour modifier l’ordre de parcours des maillons, il suffit de modifier le chaînage, par exemple,
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;

67
 struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void printData ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon ∗ l ;
int i ;
l = ( maillon ∗ ) malloc ( N ∗ s i z e o f ( maillon ) ) ;
i f ( l == NULL )
{
printf ( " Plus de mé moire " ) ;
return 1 ;
}
l−>data = 0 ;
( l + 1 )−>data = 1 ;
( l + N − 2 )−>next = l + 1 ;
( l + N − 1 )−>next = NULL ;
f o r ( i = 2 ; i < N ; i+=1)
{
( l + i )−>data = i ;
( l + i − 2 )−>next = l + i ;
}
printData ( l ) ;
free ( l ) ;
return 0 ;
}

Ce programme affiche

data = 0
data = 2
data = 4
data = 6
data = 8
data = 1
data = 3
data = 5
data = 7
data = 9

1.12.5 Utilisation de malloc

Pour le moment, nous avons stocké les éléments dans un tableau, les maillons étaient donc regroupés dans des zones
mémoire contigües. Il est possible de stocker les maillons dans les zones non contigües, tous peuvent être retrouvés à
l’aide du chaînage. Par exemple,
#include<s t d i o . h>
#include<s t d l i b . h>

68
#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;
struct maillon ∗ next ;
} maillon ;

void printData ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void freeLL ( maillon ∗ l )

{
maillon ∗ n ;
while ( l != NULL )
{
n = l−>next ;
free ( l ) ;
l = n;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon ∗ l ;
maillon ∗ current ;
maillon ∗ previous ;
int i ;
l = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( l == NULL )
return −1;
l−>data = 0 ;
previous = l ;
f o r ( i = 1 ; i < N ; i++)
{
current = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( current == NULL )
exit ( 0 ) ;
current−>data = i ;
previous−>next = current ;
previous = current ;
}
current−>next = NULL ;
printData ( l ) ;
freeLL ( l ) ;
return 0 ;
}

Ce programme affiche

data = 0

69
data = 1
data = 2
data = 3
data = 4
data = 5
data = 6
data = 7
data = 8
data = 9
Pour plus de clarté, on placera l’initialisation de la liste dans une fonction :
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;
struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void printLL ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ initLL ( i n t n )
{
maillon ∗ first ;
maillon ∗ current ;
maillon ∗ previous ;
int i ;
first = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( first == NULL )
return NULL ;
first−>data = 0 ;
previous = first ;
f o r ( i = 1 ; i < n ; i++)
{
current = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( current == NULL )
exit ( 0 ) ;
current−>data = i ;
previous−>next = current ;
previous = current ;
}
current−>next = NULL ;
return first ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

70
void freeLL ( maillon ∗ l )
{
maillon ∗ n ;
while ( l != NULL )
{
n = l−>next ;
free ( l ) ;
l = n;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon ∗ l ;
l = initLL ( N ) ;
i f ( l == NULL )
return −1;
printLL ( l ) ;
freeLL ( l ) ;
return 0 ;
}

1.12.6 Opérations
Observons de quelle façon il est possible d’effectuer certaines opérations sur une liste chaînée. Les sous-programmes
ci-dessous ont été pensé et combinés pour être les plus simples possibles...

Création d’un maillon

maillon ∗ creeMaillon ( i n t n )
{
maillon ∗ l ;
l = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( l == NULL )
exit ( 0 ) ;
l−>data = n ;
l−>next = NULL ;
return l ;
}

Insertion au début d’une liste chaînée

maillon ∗ insereDebutLL ( maillon ∗ l , i n t n )

{
maillon ∗ first = creeMaillon ( n ) ;
first−>next = l ;
return first ;
}

Création d’une liste chaînée {0, . . . , n − 1}

71
 maillon ∗ initLL ( i n t n )
{
maillon ∗ l = NULL ;
int i ;
f o r ( i = n − 1 ; i >= 0 ; i−−)
l = insereDebut ( l , i ) ;
return l ;
}

1.12.7 Listes doublement chaînées

Un maillon d’une liste doublement chaînée contient deux pointeurs, un vers le maillon précédent, et un vers le maillon
suivant.
typedef struct dmaillon
{
i n t data ;
struct dmaillon ∗ previous ;
struct dmaillon ∗ next ;
} dmaillon ;

Aussi paradoxal que cela puisse paraître, bon nombre d’opérations sont davantage aisées sur des listes doublement
chaînées. Pour se faciliter la tâche, nous manipulerons les listes chaînées à l’aide de deux pointeurs, un vers son premier
élément, et un vers son dernier :
typedef struct dLinkedList
{
struct dmaillon ∗ first ;
struct dmaillon ∗ last ;
} dLinkedList ;

Le soin d’ecrire les opérations sur ces listes vous est laissé dans le TP...

72
1.13 Conseils techniques
1.13.1 Le problème
Dès que l’on code un programme d’une certaine envergure, bon nombre de problèmes se posent.
1. Le débogage peut devenir un cauchemar sans fin.
2. Ensuite le code écrit peut être une bouillie lisible que par son auteur.
3. Le code peut contenir des redondances qui n’en facilite ni la lecture, ni le débogage.
Je passe les nombreuses difficultés et laideurs pouvant résulter d’un développement hâtif. Retenez que sans méthode,
vous ne parviendrez pas à développer un projet important, tout simplement parce que le temps de débogage sera
prohibitif, et parce que votre code, après les multiples bidouillages auxquels vous soumettrez pour déboguer sera un
gros pavé bordélique et illisible.

1.13.2 Les règles d’or

La solution au problème mentionné ci-avant réside dans l’application des règles d’or suivantes :

Généralités
Avant toute chose, rappelons quelques évidences :
1. indentez votre code, on doit pouvoir trouver, pour chaque accolade ouvrante, où se trouve l’accolade fermante
qui lui correspond en moins d’un quart de seconde.
2. utilisez des noms de variable explicites, le nom de la variable doit être suffisant pour pouvoir comprendre
à quoi elle sert.

Fonctions
Commencez par découper votre très gros problème en plein de petits problèmes que vous traiterez individuellement
avec des fonctions. Chaque fonction devra :
1. porter un nom explicite : vous avez droit à 256 caractères...
2. être précédée d’un commentaire décrivant clairement et sans paraphraser le code ce que fait la fonction.
3. tenir sur une page : il faut que vous puissiez voir toute la fonction sans avoir à utiliser l’ascenseur, et
comprendre aisément ce qu’elle fait.
4. contenir au maximum trois niveaux d’imbrication : si vous avez plus de trois blocs (boucles, conditions,
etc.) imbriqués, placez tout ce qui déborde dans une autre fonction.
5. ne jamais utiliser de variables globales : l’utilisation des variables globales est réservée à certains cas
très précis. Dans tous les autres cas, vos fonctions doivent utiliser les passages de paramètres (par adresse si
nécessaire) et les valeurs de retour.
6. être précédée de toutes les fonctions qu’elle appelle : d’une part un lecteur parcourant votre code le
comprendra plus aisément si pour chaque appel de fonction, il a déjà vu la définition de cette fonction. Ainsi
on pourra lire votre code dans l’ordre et éviter de slalomer entre les fonctions. D’autre part, cela vous évitera
d’avoir à écrire les prototypes des fonctions en début de fichier. Vous réserverez aux cas où il et impossible (ou
laid) de faire autrement les fonctions qui s’invoquent mutuellement.

Compilation séparée
Un fichier contenant plusieurs centaines de fonctions est impossible à lire, en plus d’être d’une laideur accablante. Vous
prendrez donc soin de regrouper vos fonctions dans des fichiers, de les compiler séparément et de les linker avec un
makefile.

73
1.13.3 Débogage
Vous êtes probablement déjà conscients du fait que le débogage occupe une partie très significative du temps de
développement. Aussi est-il appréciable de la diminuer autant que possible.
1. D’une part parce que lorsque ce temps devient prohibitif, il constitue une perte de temps fort malvenue.
2. D’autre part parce que les multiples bidouilles opérées pour corriger les erreurs ne font souvent que nuire à la
lisibilité du code
3. Et enfin parce qu’un temps anormalement élevé est en général une conséquence d’une analyse et d’un codage
hâtifs.
Aussi est-il généralement plus efficace de passer un peu plus de temps à coder, et beaucoup moins de temps à déboguer.
Pour ce faire :
1. Notez bien que tous les conseils énoncés précédemment sont encore d’actualité. En particulier ceux sur les
fonctions.
2. Construisez les fonctions dans l’ordre inverse de l’ordre d’invocation, et testez-les une par une. Les bugs sont
beaucoup plus facile à trouver quand on les cherche dans une dizaine de lignes que dans une dizaine de pages.
Et en assemblant des fonctions qui marchent correctement, vous aurez plus de chances de rédiger un programme
correct.
3. N’hésitez pas à utiliser des logiciels comme valgrind. valgrind examine l’exécution de votre code et vous rapporte
bon nombre d’utilisation irrégulière de la mémoire (pointeurs fous, zones non libérées, etc.)

1.13.4 Durée de vie du code

Si vous ne voulez pas qu’un jour un développeur fasse un sélectionner/supprimer sur votre code, vous devez avoir en
tête l’idée que quand quelqu’un reprend ou utilise votre code vous devez réduire au minimum à la fois le temps qu’il
mettra à le comprendre et le nombre de modifications qu’il devra faire.

Le code doit être réutilisable

Cela signifie qu’un autre programmeur doit pouvoir poursuivre votre projet en faisant un minimum de modifications.
Autrement dit, un autre programmeur doit pouvoir appeler vos fonctions aveuglément et sans même regarder ce qu’il
y a dedans. Les noms des fonctions et les commentaires décrivant leurs comportement doivent être clairs, précis, et
bien évidemment exempt de bugs. Sinon, un sélectionner/supprimer mettra fin à la courte vie de votre code. Notez
bien par ailleurs que si vous avez réparti votre code dans des fichiers séparés de façon intelligente, votre code sera bien
plus simple à réutiliser.

Le code doit être adaptable

Supposons que pour les besoins d’un projet, un autre développeur veuille partir de votre code, par exemple utiliser des
listes chaînées au lieu de tableau, ou encore ajouter une sauvegarde sur fichier, etc. Si votre code est bien découpé, il
n’aura que quelques fonctions à modifier. Si par contre, vous avez mélangé affichage, saisies, calculs, sauvegardes, etc.
Notre développeur devra passer un temps considérable à bidouiller votre code, et cela sans aucune certitude quand à
la qualité du résultat. Il fera donc un sélectionner/supprimer et recodera tout lui-même.

1.13.5 Exemple : le carnet de contacts

Je me suis efforcé, autant que possible, de suivre mes propres conseils et de vous donner un exemple. Je vous laisse
à la fois observer mes recommandations dans le code qui suit, et traquer les éventuelles effractions que j’aurais pu
commettre.

util.h

74
#i f n d e f UTIL_H
#define UTIL_H

/∗
S a i s i t une c h a i n e de c a r a c t e r e s de l o n g u e u r sizeMax a l ’ a d r e s s e
adr , e l i m i n e l e c a r a c t e r e de r e t o u r a l a l i g n e e t v i d e s i n e c e s s a i r e
t o u s l e s c a r a c t e r e s s u p p l e m e n t a i r e s du tampon de s a i s i e .
∗/

void getString ( char∗ adr , i n t sizeMax ) ;

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
S a i s i t un e n t i e r .
∗/

i n t getInt ( ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Echange l e s c h a i n e s de c a r a c t e r e s s1 e t s2 , de t a i l l e s
maximales sizeMax .
∗/

void swapStrings ( char∗ s1 , char∗ s2 , i n t sizeMax ) ;

#endif

util.c

#include<s t d i o . h>
#include<s t d l i b . h>
#include<s t r i n g . h>

void getString ( char∗ adr , i n t sizeMax )

{
i n t len ;
fgets ( adr , sizeMax , stdin ) ;
len = strlen ( adr ) ;
i f ( ∗ ( adr + len − 1 ) == ’\n ’ )
∗ ( adr + len − 1 ) = 0 ;
else
while ( getchar ( ) != ’\n ’ ) ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

i n t getInt ( )
{
char tab [ 1 0 ] ;
getString ( tab , 1 0 ) ;
return atoi ( tab ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

75
void swapStrings ( char∗ s1 , char∗ s2 , i n t sizeMax )
{
char temp [ sizeMax ] ;
strncpy ( temp , s1 , sizeMax ) ;
strncpy ( s1 , s2 , sizeMax ) ;
strncpy ( s2 , temp , sizeMax ) ;
∗ ( s1 + sizeMax − 1 ) = 0 ;
∗ ( s2 + sizeMax − 1 ) = 0 ;
}

tableau.h

#i f n d e f TABLEAU_H
#define TABLEAU_H

#define SIZE_MAIL 30
#define NB_MAILS 6

/∗
Implemente un c a r n e t de c o n t a c t s a l ’ a i d e d ’ un t a b l e a u .
Une c a s e i n o c c u p e e e s t r e p r e s e n t e e par une c h a i n e v i d e ,
t o u t e s l e s a d r e s s e s s o n t d i s p o s e e s par o r d r e a l p h a b e t i q u e
au d e b u t du t a b l e a u .
∗/

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l e c a r n e t de c o n t a c t s .
∗/

void afficheMails ( char∗ mails ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l ’ a d r e s s e du i −eme m a i l .
∗/

char∗ getMail ( char∗ mails , i n t i ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l e nombre de c o n t a c t s .
∗/

i n t nombreMails ( char∗ mails ) ;

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Creee un t a b l e a u de d ’ e−m a i l s e t l e r e t o u r n e . Ce t a b l e a u c o n t i e n t
NB_MAILS c h a i n e s de c a p a c i t e s l o n g u e u r SIZE_MAIL i n i t i a l i s e s
avec des chaines v i d e s .
∗/

char∗ creerMails ( ) ;

76
/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
L i b e r e l a memoire
∗/

void detruitMails ( char∗ mails ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Supprime l ’ a d r e s s e dont l ’ i n d i c e e s t p a s s e en parametre .
∗/

void supprimeMail ( char∗ mails , i n t indice ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A j o u t e l e m a i l m a i l dans l e t a b l e a u m a i l s .
∗/

void ajouteMail ( char∗ mails , char∗ mail ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Remplace l e i n d i c e −eme m a i l du t a b l e a u m a i l s par m a i l . L ’ i n d i c e
e s t suppose v a l i d e .
∗/

void changeMail ( char∗ mails , char∗ mail , i n t indice ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
E c r i t t o u s l e s c o n t a c t s de m a i l s dans l e f i c h i e r nomFichier .
∗/

void sauvegardeMails ( char∗ mails , char∗ nomFichier ) ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
L i t t o u s l e s c o n t a c t s de m a i l s dans l e f i c h i e r nomFichier .
∗/

void restaureMails ( char∗ mails , char∗ nomFichier ) ;

#endif

tableau.c

#include " ../../ src / methodo / tableau .h"

#include<s t d i o . h>
#include<m a l l o c . h>

77
#include<s t r i n g . h>
#include<s t d l i b . h>

#include " util .h"

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

void afficheMails ( char∗ mails )

{
i n t indice = 0 ;
printf ( " Liste des contacts : \n" ) ;
while ( indice < NB_MAILS && ∗ getMail ( mails , indice ) )
{
printf ( "%d : %s\n" , indice + 1 , getMail ( mails , indice ) ) ;
indice++;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

char∗ getMail ( char∗ mails , i n t i )

{
return mails + i ∗ SIZE_MAIL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

i n t nombreMails ( char∗ mails )

{
i n t indice = 0 ;
while ( indice < NB_MAILS && ∗ getMail ( mails , indice ) )
indice++;
return indice ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

char∗ creerMails ( )
{
char∗ adr = ( char ∗ ) malloc ( s i z e o f ( char ) ∗ SIZE_MAIL ∗ NB_MAILS ) ;
int i ;
i f ( adr == NULL )
{
printf ( " Heap overflow " ) ;
exit ( 0 ) ;
}
f o r ( i = 0 ; i < NB_MAILS ; i++)
∗ getMail ( adr , i ) = 0 ;
return adr ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗∗ ∗ ∗/

void detruitMails ( char∗ mails )

{
free ( mails ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

78
void supprimeMail ( char∗ mails , i n t indice )
{
while ( indice < NB_MAILS && ∗ getMail ( mails , indice + 1 ) )
{
strncpy ( getMail ( mails , indice ) ,
getMail ( mails , indice + 1 ) ,
SIZE_MAIL ) ;
indice++;
}
i f ( indice < NB_MAILS )
∗ getMail ( mails , indice ) = 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l ’ i n d i c e du p r e m i e r emplacement l i b r e dans
l e t a b l e a u m a i l s c o n t e n a n t nbMax a d r e s s e s . On s u p p o s e que l e t a b l e a u
n ’ e s t pas p l e i n .
∗/

i n t indicePremiereChaineVide ( char∗ mails , i n t indiceMax )

{
i n t milieu ;
i f ( indiceMax == 0 )
return 0 ;
milieu = indiceMax / 2 ;
i f ( ! ∗ getMail ( mails , milieu ) )
return indicePremiereChaineVide ( mails , milieu ) ;
else
return milieu + 1 +
indicePremiereChaineVide ( getMail ( mails , milieu + 1 ) ,
indiceMax − ( milieu + 1 ) ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
T r i e l e t a b l e a u m a i l s c o n t e n a n t ( i n d i c e + 1) e l e m e n t s ,
ne f o n c t i o n n e que s i t o u s l e s a u t r e s e l e m e n t s
sont t r i e s .
∗/

void placeMail ( char∗ mails , i n t indice )

{
i f ( indice > 0 && indice < NB_MAILS &&
strncmp ( getMail ( mails , indice ) ,
getMail ( mails , indice − 1 ) ,
SIZE_MAIL ) < 0 )
{
swapStrings ( getMail ( mails , indice ) ,
getMail ( mails , indice − 1 ) ,
SIZE_MAIL ) ;
placeMail ( mails , indice − 1 ) ;
}
else
i f ( indice >= 0 && indice < NB_MAILS − 1 &&
∗ getMail ( mails , indice + 1 ) &&

79
 strncmp ( getMail ( mails , indice ) ,
getMail ( mails , indice + 1 ) ,
SIZE_MAIL ) > 0 )
{
swapStrings ( getMail ( mails , indice ) ,
getMail ( mails , indice + 1 ) ,
SIZE_MAIL ) ;
placeMail ( mails , indice + 1 ) ;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

void ajouteMail ( char∗ mails , char∗ mail )

{
i n t indice ;
i f ( ∗ getMail ( mails , NB_MAILS − 1 ) )
{
printf ( " Carnet de contact plein .\ n" ) ;
}
else
{
indice = indicePremiereChaineVide ( mails , NB_MAILS − 1 ) ;
strncpy ( getMail ( mails , indice ) , mail , SIZE_MAIL ) ;
∗ ( getMail ( mails , indice ) + SIZE_MAIL − 1 ) = 0 ;
placeMail ( mails , indice ) ;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

void changeMail ( char∗ mails , char∗ mail , i n t indice )

{
strncpy ( getMail ( mails , indice ) , mail , SIZE_MAIL ) ;
∗ ( getMail ( mails , indice ) + SIZE_MAIL − 1 ) = 0 ;
placeMail ( mails , indice ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

void sauvegardeMails ( char∗ mails , char∗ nomFichier )

{
FILE ∗ f = fopen ( nomFichier , "w" ) ;
int i ;
i f ( f == NULL )
printf ( " Impossible d ’ ouvrir le fichier %s" , nomFichier ) ;
else
f o r ( i = 0 ; i < NB_MAILS && ∗ getMail ( mails , i ) ; i++)
fwrite ( getMail ( mails , i ) , s i z e o f ( char ) , SIZE_MAIL , f ) ;
fclose ( f ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

void restaureMails ( char∗ mails , char∗ nomFichier )

{
FILE ∗ f = fopen ( nomFichier , "r" ) ;
i n t i , ret = 1 ;
i f ( f == NULL )

80
 printf ( " Impossible d ’ ouvrir le fichier %s" , nomFichier ) ;
else
f o r ( i = 0 ; i < NB_MAILS && ret ; i++)
ret = fread ( getMail ( mails , i ) , s i z e o f ( char ) , SIZE_MAIL , f ) ;
fclose ( f ) ;
}

eMails.c

#include<s t d i o . h>
#include<s t d l i b . h>

#include " tableau .h"

#include " util .h"

#define AFFICHER_OPTION 1
#define SUPPRIMER_OPTION 2
#define MODIFIER_OPTION 3
#define AJOUTER_OPTION 4
#define QUITTER_OPTION 5
#define NB_OPTIONS 5

#define F_NAME ". adressesMails . txt "

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l e menu p r i n c i p a l .
∗/

void afficheMenu ( )
{
printf ( "\ nOptions disponibles :\ n"
"%d - afficher les contacts \n"
"%d - supprimer un contact \n"
"%d - modifier un contact \n"
"%d - ajouter un contact \n"
"%d - quitter \n" ,
AFFICHER_OPTION ,
SUPPRIMER_OPTION ,
MODIFIER_OPTION ,
AJOUTER_OPTION ,
QUITTER_OPTION ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l e menu p r i n c i p a l , r e t o u r n e l a v a l e u r s a i s i e par
l ’ utilisateur .
∗/

i n t choisitOptionMenu ( )
{
i n t option ;
do
{
afficheMenu ( ) ;

81
 printf ( " Choisissez une option en saisissant son numero : " ) ;
option = getInt ( ) ;
i f ( option <= 0 && option > NB_OPTIONS )
printf ( " option invalide \n" ) ;
}
while ( option <= 0 && option > NB_OPTIONS ) ;
return option ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Demande a l ’ u t i l i s a t e u r de s a i s i r un mail , l e p l a c e
a l ’ a d r e s s e adr .
∗/

void saisitMail ( char∗ adr )

{
printf ( " Veuillez saisir l ’ adresse e - mail de votre contact : " ) ;
do
{
getString ( adr , SIZE_MAIL ) ;
i f ( ! ∗ adr )
printf ( " Vous devez saisir une adresse " ) ;
}
while ( ! ∗ adr ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l a l i s t e de m a i l s , s a i s i t e t r e t o u r n e l e numero de
l ’ un d ’ eux .
∗/

i n t choisitMail ( char∗ mails )

{
i n t i , nbMails ;
nbMails = nombreMails ( mails ) ;
afficheMails ( mails ) ;
do
{
printf ( " Choisissez un mail en saisissant son numero : " ) ;
i = getInt ( ) ;
i f ( i <= 0 && i > nbMails )
printf ( " Cet indice n ’ existe pas ! \n" ) ;
}
while ( i <= 0 && i > nbMails ) ;
return i − 1 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
S a i s i t un m a i l m e t un i n d i c e i , p u i s r e m p l a c e l e i −eme m a i l
de m a i l s par m.
∗/

void modifierOption ( char∗ mails )

82
{
int i ;
char m [ SIZE_MAIL ] ;
printf ( " Modification d ’un contact : \n" ) ;
i = choisitMail ( mails ) ;
saisitMail ( m ) ;
changeMail ( mails , m , i ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
S a i s i t un m a i l m e t un i n d i c e i , p u i s r e m p l a c e l e i −eme m a i l
de m a i l s par m.
∗/

void ajouterOption ( char∗ mails )

{
char m [ SIZE_MAIL ] ;
printf ( " Ajout d ’un contact : \n" ) ;
saisitMail ( m ) ;
ajouteMail ( mails , m ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
S a i s i t un i n d i c e i , p u i s supprime l e i −eme m a i l dans m a i l s .
∗/

void supprimerOption ( char∗ mails )

{
int i ;
printf ( " Suppression d ’un contact : \n" ) ;
i = choisitMail ( mails ) ;
supprimeMail ( mails , i ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Sauve l e s m a i l s dans l e f i c h i e r F_NAME e t a f f i c h e un message
d ’ adieu .
∗/

void quitterOption ( char∗ mails )

{
sauvegardeMails ( mails , F_NAME ) ;
printf ( " Au revoir !\ n" ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l e menu p r i n c i p a l , s a i s i t une o p t i o n , e t e f f e c t u e l e
traitement necessaire .
∗/

void executeMenu ( char∗ mails )

83
{
i n t option ;
do
{
option = choisitOptionMenu ( ) ;
switch ( option )
{
case AFFICHER_OPTION :
afficheMails ( mails ) ;
break ;
case AJOUTER_OPTION :
ajouterOption ( mails ) ;
break ;
case MODIFIER_OPTION :
modifierOption ( mails ) ;
break ;
case SUPPRIMER_OPTION :
supprimerOption ( mails ) ;
break ;
case QUITTER_OPTION :
quitterOption ( mails ) ;
break ;
default :
break ;
}
}
while ( option != QUITTER_OPTION ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
char∗ mails = creerMails ( ) ;
restaureMails ( mails , F_NAME ) ;
executeMenu ( mails ) ;
detruitMails ( mails ) ;
return 0 ;
}

makefile

all : eMails eMails . tgz

util . o : util . c util . h

gcc −Wall −c util . c

tableau . o : tableau . c tableau . h util . h

gcc −Wall −c tableau . c

eMails . o : eMails . c tableau . h util . h

gcc −Wall −c eMails . c

eMails : util . o tableau . o eMails . o

gcc −o eMails −Wall util . o tableau . o eMails . o

eMails . tgz : util . h util . c tableau . h tableau . c eMails . c makefile

tar cvfz eMails . tgz util . h util . c tableau . h tableau . c eMails . c makefile

84
Chapitre 2

Exercices

2.1 Variables et opérateurs

f

2.1.1 Entiers
Exercice 1 Saisie et affichage
Saisir une variable entière, afficher sa valeur.

Exercice 2 Permutation de 2 variables

Saisir deux variables et les permuter avant de les afficher.

Exercice 3 Permutation de 4 valeurs

Ecrire un programme demandant à l’utilisateur de saisir 4 valeurs A, B, C, D et qui permute les variables de la façon
suivante :
noms des variables A B C D
valeurs avant la permutation 1 2 3 4
valeurs après la permutation 3 4 1 2

Exercice 4 Permutation de 5 valeurs

On considère la permutation qui modifie cinq valeurs de la façon suivante :
noms des variables A B C D E
valeurs avant la permutation 1 2 3 4 5
valeurs après la permutation 4 3 5 1 2
Ecrire un programme demandant à l’utilisateur de saisir 5 valeurs que vous placerez dans des variables appelées A, B,
C, D et E. Vous les permuterez ensuite de la façon décrite ci-dessus.

2.1.2 Flottants
Exercice 5 Saisie et affichage
Saisir une variable de type float, afficher sa valeur.

Exercice 6 Moyenne arithmétique

Saisir 3 valeurs, afficher leur moyenne.

85
Exercice 7 Surface du rectangle
Demander à l’utilisateur de saisir les longueurs et largeurs d’un rectangle, afficher sa surface.

Exercice 8 Moyennes arithmétique et géométrique

Demander à l’utilisateur de saisir deux valeurs a et b, afficher ensuite la différence entre la moyenne arithmétique
(a + b) √
et la moyenne géométrique ab. Pour indication, sqrt(f) est la racine carrée du flottant f, cette fonction est
2
disponible en important \#include<math.h>.

Exercice 9 Cartons et camions

Nous souhaitons ranger des cartons pesant chacun k kilos dans un camion pouvant transporter M kilos de marchandises.
Ecrire un programme C demandant à l’utilisateur de saisir M et k, que vous représenterez avec des nombres flottants,
et affichant le nombre (entier) de cartons qu’il est possible de placer dans le camion. N’oubliez pas que lorsque l’on
affecte une valeur flottante à une variable entière, les décimales sont tronquées.

2.1.3 Caractères
Exercice 10 Prise en main
Affectez le caractère ’a’ à une variable de type char, affichez ce caractère ainsi que son code ASCII.

Exercice 11 - Successeur
Ecrivez un programme qui saisit un caractère et qui affiche son successeur dans la table des codes ASCII.

Exercice 11 - Casse
Ecrivez un programme qui saisit un caractère miniscule et qui l’affiche en majuscule.

Exercice 11 Codes ASCII

Quels sont les codes ASCII des caractères ’0’, ’1’, . . ., ’9’

2.1.4 Opérations sur les bits (difficiles)

Exercice 12 Codage d’adresses IP
Une adresse IP est constituée de 4 valeurs de 0 à 255 séparées par des points, par exemple [Link] , chacun de ces
nombres peut se coder sur 1 octet. Comme une variable de type long occupe 4 octets en mémoire, il est possible de
s’en servir pour stocker une adresse IP entière. Ecrivez un programme qui saisit dans des unsigned short les 4 valeurs
d’une adresse IP, et place chacune d’elle sur un octet d’une variable de type long. Ensuite vous extrairez de cet entier
les 4 nombres de l’adresse IP et les afficherez en les séparant par des points.

Exercice 13 Permutation circulaire des bits

Effectuez une permutation circulaire vers la droite des bits d’une variable b de type unsigned short, faites de même
vers la droite.

Exercice 14 Permutation de 2 octets

Permutez les deux octets d’une variable de type unsigned short saisie par l’utilisateur.

Exercice 15 Inversion de l’ordre de 4 octets

Inversez l’ordre des 4 octets d’une variable de type long saisie par l’utilisateur. Utilisez le code du programme sur les
adresses IP pour tester votre programme.

86
2.1.5 Morceaux choisis (difficiles)
Exercice 16 Pièces de monnaie
Nous disposons d’un nombre illimité de pièces de 0.5, 0.2, 0.1, 0.05, 0.02 et 0.01 euros. Nous souhaitons, étant donné
une somme S, savoir avec quelles pièces la payer de sorte que le nombre de pièces utilisée soit minimal. Par exemple,
la somme de 0.96 euros se paie avec une pièce de 0.5 euros, deux pièces de 0.2 euros, une pièce de 0.05 euros et une
pièce de 0.01 euros.
1. Le fait que la solution donnée pour l’exemple est minimal est justifié par une idée plutôt intuitive. Expliquez
ce principe sans excès de formalisme.
2. Ecrire un programme demandant à l’utilisateur de saisir une valeur comprise entre 0 et 0.99. Ensuite, affichez
le détail des pièces à utiliser pour constituer la somme saisie avec un nombre minimal de pièces.

Exercice 17 Modification du dernier bit

Modifiez le dernier bit d’une variable a saisie par l’utilisateur.

Exercice 18 Associativité de l’addition flottante

L’ensemble des flottants n’est pas associatif, cela signifie qu’il existe trois flottants a, b et c, tels que (a+b)+c 6= a+(b+c).
Trouvez de tels flottants et vérifiez-le dans un programme.

Exercice 19 Permutation sans variable temporaire

Permutez deux variables a et b sans utiliser de variables temporaires.

87
2.2 Traitements conditionnels
2.2.1 Prise en main
Exercice 1 Majorité
Saisir l’âge de l’utilisateur et lui dire s’il est majeur.

Exercice 2 Valeur Absolue

Saisir une valeur, afficher sa valeur absolue.

Exercice 3 Admissions
Saisir une note, afficher "ajourné" si la note est inférieure à 8, "rattrapage" entre 8 et 10, "admis" dessus de 10.

Exercice 4 Assurances
Une compagnie d’assurance effectue des remboursements sur lesquels est ponctionnée une franchise correspondant à
10% du montant à rembourser. Cependant, cette franchise ne doit pas excéder 4000 euros. Demander à l’utilisateur
de saisir le montant des dommages, afficher ensuite le montant qui sera remboursé ainsi que la franchise.

Exercice 5 Valeurs distinctes parmi 2

Afficher sur deux valeurs saisies le nombre de valeurs disctinctes.

Exercice 6 Plus petite valeur parmi 3

Afficher sur trois valeurs saisies la plus petite.

Exercice 7 Recherche de doublons

Ecrire un algorithme qui demande à l’utilisateur de saisir trois valeurs et qui lui dit s’il s’y trouve un doublon.

Exercice 8 Valeurs distinctes parmi 3

Afficher sur trois valeurs saisies le nombre de valeurs disctinctes.

Exercice 9 ax + b = 0
Saisir les coefficients a et b et afficher la solution de l’équation ax + b = 0.

Exercice 10 ax2 + bx + c = 0
Saisir les coefficients a, b et c, afficher la solution de l’équation ax2 + bx + c = 0.

2.2.2 Switch
Dans le problème suivant, vous serez confronté au problème dit de saisie bufferisée (ce néologisme est très vilain).
Explication : lorsque vous saisissez des valeurs au clavier, elles sont placées dans le tampon de saisie (buffer). Une fois
que vous avez saisi <entrée>, (le caractère ’$\setminus$n’), les données sont lues directement dans le buffer par scanf.
Mais cette fonction ne lira que le caractère qui a été saisi, et le ’$\setminus$n’ qui a validé la saisie restera dans le
buffer jusqu’à la prochaine saisie d’un caractère. L’instruction getchar(); lit un octet dans le buffer. Donc, à chaque
fois que vous avez placé un ’$\setminus$n’ dans le buffer, pensez à le vider avec un getchar();.

88
Exercice 11 Calculatrice
Ecrire un programme demandant à l’utilisateur de saisir
— deux valeurs a et b, de type int ;
— un opérateur op de type char, vérifiez qu’il s’agit del’une des valeurs suivantes : +, −, ∗, /.
Puis affichez le résultat de l’opération a op b.

2.2.3 L’échiquier
On indice les cases d’un échiquer avec deux indices i et j variant tous deux de 1 à 8. La case (i, j) est sur la ligne i et
la colonne j. Par convention, la case (1, 1) est noire.

Exercice 12 Couleurs
Ecrire un programme demandant à l’utilisateur de saisir les deux coordonnées i et j d’une case, et lui disant s’il s’agit
d’une case blanche ou noire.

Exercice 13 Cavaliers
Ecrire un programme demandant à l’utilisateur de saisir les coordonnées (i, j) d’une première case et les coordonnées
(i0 , j 0 ) d’une deuxième case. Dites-lui ensuite s’il est possible de déplacer un cavalier de (i, j) à (i0 , j 0 ).

Exercice 14 Autres pièces

Même exercice avec la tour, le fou, la dame et le roi. Utilisez un switch et présentez le programme de la sorte :

Quelle piece souhaitez-vous deplacer ?

0 = Cavalier
1 = Tour
2 = Fou
3 = Dame
4 = Roi
3
Saisissez les coordonnees de la case de depart :
A = 2
A = 1
Saisissez les coordonnees de la case d’arrivee :
A = 6
A = 5
Le mouvement (2, 1) -> (6, 5) est valide.

2.2.4 Heures et dates

Exercice 15 Opérations sur les heures
Ecrire un programme qui demande à l’utilisateur de saisir une heure de début (heures + minutes) et une heure de fin
(heures + minutes aussi). Ce programme doit ensuite calculer en heures + minutes le temps écoulé entre l’heure de
début et l’heure de fin. Si l’utilisateur saisit 10h30 et 12h15, le programme doit lui afficher que le temps écoulé entre
l’heure de début et celle de fin est 1h45. On suppose que les deux heures se trouvent dans la même journée, si celle de
début se trouve après celle de fin, un message d’erreur doit s’afficher. Lors la saisie des heures, séparez les heures des
minutes en demandant à l’utilisateur de saisir :
— heures de début
— minutes de début
— heures de fin
— minutes de fin

89
Exercice 16 Le jour d’après
Ecrire un programme permettant de saisir une date (jour, mois, année), et affichant la date du lendemain. Saisissez les
trois données séparément (comme dans l’exercice précédent). Prenez garde aux nombre de jours que comporte chaque
mois, et au fait que le mois de février comporte 29 jours les années bissextiles. Allez sur [Link]
org/wiki/Ann\%C3\%A9e_bissextilepourconnaÃőtrelesrÃĺglesexactes, je vous avais dit que les années étaient
bissextiles si et seulement si elles étaient divisible par 4, après vérification, j’ai constaté que c’était légèrement plus
complexe. Je vous laisse vous documenter et retranscrire ces règles de la façon la plus simple possible.

2.2.5 Intervalles et rectangles

Exercice 17 Intervalles bien formés
Demandez à l’utilisateur de saisir les deux bornes a et b d’un intervalle [a, b]. Contrôler les valeurs saisies.

Exercice 18 Appartenance
Demandez-lui ensuite de saisir une valeur x, dites-lui si x ∈ [a, b]

Exercice 19 Intersections
Demandez-lui ensuite de saisir les bornes d’un autre intervalle [a0 , b0 ]. Contrôlez la saisie. Dites-lui ensuite si
— [a, b] ⊂ [a0 , b0 ]
— [a0 , b0 ] ⊂ [a, b]
— [a0 , b0 ] ∩ [a, b] = ∅.

Exercice 20 Rectangles
Nous représenterons un rectangle R aux cotés parallèles aux axes des abscisses et ordonnées à l’aide des coordonnées
de deux points diamétralement opposés, le point en haut à gauche, de coordonnées (xHautGauche, yHautGauche), et
le point en bas à droite, de coordonnées (xBasDroite, yBasDroite). Demander à l’utilisateur de saisir ces 4 valeurs,
contrôlez la saisie.

Exercice 21 Appartenance
Demandez à l’utilisateur de saisir les 2 coordonnées d’un point (x, y) et dites à l’utilisateur si ce point se trouve dans
le rectangle R.

Exercice 22 Intersection
Demandez à l’utilisateur de saisir les 4 valeurs

(xHautGauche0 , yHautGauche0 , xBasDroite0 , yBasDroite0 )

permettant de spécifier un deuxième rectangle R0 . Précisez ensuite si

— R ⊂ R0
— R0 ⊂ R
— R ∩ R0 = ∅

2.2.6 Préprocesseur
Exercice 23 L’échiquer
Même exercice mais en utilisant le plus possible les spécifications suivantes :
#include<s t d i o . h>
#include<s t d l i b . h>

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

90
#define CAVALIER 0
#define TOUR 1
#define FOU 2
#define DAME 3
#define ROI 4

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define MAIN i n t main ( ) \

{

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define FINMAIN return 0 ; \

}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define SI i f (

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define ALORS ) {

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define SINON } e l s e {

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define FINSI }

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define SUIVANT( var ) switch ( var ) {

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define FINSUIVANT( d e f ) default : d e f }

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define CAS( v a l e u r , i n s t r u c t i o n s ) case v a l e u r : i n s t r u c t i o n s \

break ;

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define PIECES_LIST \
printf ( "% hu = Cavalier \n" , CAVALIER ) ; \
printf ( "% hu = Tour \n" , TOUR ) ; \
printf ( "% hu = Fou \n" , FOU ) ; \
printf ( "% hu = Dame \n" , DAME ) ; \
printf ( "% hu = Roi \n" , ROI )

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define CHECK_COORD( i ) \
SI i<1 | | i>8 ALORS \
printf ( " coordonnee invalide \n" ) ; \

91
 return 1 ; \
FINSI

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define GET_VAR(A, B) \
printf ( "A = " ) ; \
scanf ( "% hu " , &B ) ; \
CHECK_COORD ( B ) ;

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define PRINT_VALID p r i n t f ( " valide " )

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define PRINT_INVALID p r i n t f ( " invalide " )

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define FATAL_ERROR p r i n t f ( " System Error . It is recommended that " \

" you format your hard disk ." ) ; \
return 1 ;

/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/

#define CONDITIONAL_PRINT( cond ) \

SI cond ALORS \
PRINT_VALID ; \
SINON \
PRINT_INVALID ; \
FINSI

2.2.7 Nombres et lettres

Exercice 24 Conversion numérique → français (très difficile)
Ecrire un programme saisissant un unsigned long et affichant sa valeur en toutes lettres. Rappelons que 20 et 100
s’accordent en nombre s’ils ne sont pas suivis d’un autre mot (ex. : quatre-vingts, quatre-vingt-un). Mille est invariable
(ex. : dix mille) mais pas million (ex. : deux millions) et milliard (ex. : deux milliards). Depuis 1990, tous les mots
sont séparés de traits d’union (ex. : quatre-vingt-quatre), sauf autour des mots mille, millions et milliard (ex. : deux
mille deux-cent-quarante-quatre, deux millions quatre-cent mille deux-cents). (source : [Link]
com/[Link]). Par exemple,

Saisissez un nombre = 1034002054

1034002054 : un milliard trente-quatre millions deux mille cinquante-quatre

Vous prendrez soin de respecter les espacements, les tirets, et de ne pas faire de fautes d’orthographe. Vous userez et
abuserez de macros-instructions pour simplifier le plus possible votre code.

92
2.3 Boucles
2.3.1 Compréhension
Exercice 1 Programme mystère 1
Qu’affiche le programme suivant ?
#include<s t d i o . h>
#define N 5

i n t main ( )
{
int a = 1 , b = 0 ;
while ( a <= N )
b += a++;
printf ( "%d , %d\n" , a , b ) ;
return 0 ;
}

Exercice 2 Programme mystère 2

Qu’affiche le programme suivant ?
#include<s t d i o . h>
#define M 3
#define N 4

i n t main ( )
{
int a , b , c = 0 , d ;
f o r ( a = 0 ; a < M ; a++)
{
d = 0;
f o r ( b = 0 ; b < N ; b++)
d+=b ;
c += d ;
}
printf ( "a = %d , b = %d , c = %d , d = %d" , a , b , c , d ) ;
return 0 ;
}

Exercice 3 Programme mystère 3

Qu’affiche le programme suivant ?
#include<s t d i o . h>

i n t main ( )
{
int a , b , c , d ;
a = 1; b = 2;
c = a/b ;
d = ( a==b ) ? 3 : 4 ;
printf ( "c = %d , d = %d\n" , c , d ) ;
a = ++b ;
b %= 3 ;
printf ( "a = %d , b = %d\n" , a , b ) ;
b = 1;

93
 f o r ( a = 0 ; a <= 10 ; a++)
c = ++b ;
printf ( "a = %d , b = %d , c = %d , d = %d\n" , a , b , c , d ) ;
return 0 ;
}

2.3.2 Utilisation de toutes les boucles

Les exercices suivants seront rédigés avec les trois types de boucle : tant que, répéter jusqu’à et pour.

Exercice 4 Compte à rebours

Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant toutes les valeurs
n, n − 1, . . . , 2, 1, 0.

Exercice 5 Factorielle
Ecrire un programme calculant la factorielle (factorielle n = n! = 1 × 2 × . . . × n et 0! = 1) d’un nombre saisi par
l’utilisateur.

2.3.3 Choix de la boucle la plus appropriée

Pour les exercices suivants, vous choisirez la boucle la plus simple et la plus lisible.

Exercice 7 Table de multiplication

Ecrire un programme affichant la table de multiplication d’un nombre saisi par l’utilisateur.

Exercice 8 Tables de multiplications

Ecrire un programme affichant les tables de multiplications des nombres de 1 à 10 dans un tableau à deux entrées.

Exercice 9 Puissance
Ecrire un programme demandant à l’utilisateur de saisir deux valeurs numériques b et n (vérifier que n est positif) et
affichant la valeur bn .

2.3.4 Morceaux choisis

Exercice 11 Approximation de 2 par une série
+∞
X 1
On approche le nombre 2 à l’aide de la série . Effectuer cette approximation en calculant un grand nombre de
i=0
2i
terme de cette série. L’approximation est-elle de bonne qualité ?

Exercice 12 Approximation de e par une série

+∞
X 1
Mêmes questions qu’à l’exercice précédent en e à l’aide de la série .
i=0
i!

Exercice 13 Approximation de ex par une série

+∞ i
X x
Calculer une approximation de ex à l’aide de la série ex = .
i=0
i!

94
Exercice 14 Conversion d’entiers en binaire
Ecrire un programme qui affiche un unsigned short en binaire. Vous utiliserez l’instruction sizeof(unsigned short),
qui donne en octets la taille de la représentation en mémoire d’un unsigned short.

Exercice 15 Conversion de décimales en binaire

Ecrire un programme qui affiche les décimales d’un double en binaire.

Exercice 16 Inversion de l’ordre des bits

Ecrire un programme qui saisit une valeur de type unsigned short et qui inverse l’ordre des bits. Vous testerez ce
programme en utilisant le précédent.

Exercice 17 Joli carré

Ecrire un programme qui saisit une valeur n et qui affiche le carré suivant (n = 5 dans l’exemple) :
n = 5
X X X X X

X X X X X

X X X X X

X X X X X

X X X X X

Exercice 18 Racine carrée par dichotomie

√
Ecrire un algorithme demandant à l’utilisateur de saisir deux valeurs numériques x et p et affichant x avec une
précision p. On utilisera une méthode par dichotomie : à la k-ème itération, on cherche x dans l’intervalle [min, sup],
on calcule le milieu m de cet intervalle (à vous de trouver comment le√calculer). Si cet intervalle est suffisament petit
(à vous de trouver quel critère utiliser), afficher m. Sinon, vérifiez si x se trouve dans [inf, m] ou dans [m, sup], et
modifiez les variables inf et sup en conséquence. Par exemple, calculons la racine carrée√de 10 avec√une précision 0.5,
— Commençons par la chercher dans [0, 10], on a m = 5, comme 52 > 10, alors 5 > 10, donc 10 se trouve dans
l’intervalle [0, 5].
2 √
— On recommence, m = 2.5, comme 52 = 25 4 < 10,√ alors 25 < 10, on poursuit la recherche dans [ 52 , 5]
√
— On a m = 3.75, comme 3.752 > 10, alors 3.75 > 10√et 10√∈ [2.5, 3.75]
— On a m = 3.125, comme 3.1252 < 10, alors 3.125 < 10 et 10 ∈ [3.125, 3.75]
— Comme l’étendue √ de l’intervalle [3.125, 3.75] est inférieure 2 × 0.5, alors m = 3.4375 est une approximattion à
0.5 près de 10.

2.3.5 Extension de la calculatrice

Une calculatrice de poche prend de façon alternée la saisie d’un opérateur et d’une opérande. Si l’utilisateur saisit 3,
+ et 2, cette calculatrice affiche 5, l’utilisateur a ensuite la possibilité de se servir de 5 comme d’une opérande gauche
dans un calcul ultérieur. Si l’utilisateur saisit par la suite ∗ et 4, la calculatrice affiche 20. La saisie de la touche = met
fin au calcul et affiche un résultat final.

Exercice 19 Calculatrice de poche

Implémentez le comportement décrit ci-dessus.

95
Exercice 20 Puissance
Ajoutez l’opérateur $ qui calcule ab , vous vous restreindrez à des valeurs de b entières et positives.

Exercice 21 Opérations unaires

Ajoutez les opérations unaires racine carrée et factorielle.

96
2.4 Tableaux
2.4.1 Exercices de compréhension
Qu’affichent les programmes suivants ?

Exercice 1 Programme mystère

char C [ 4 ] ;
int k ;
C [ 0 ] = ’a ’ ;
C [ 3 ] = ’J ’ ;
C [ 2 ] = ’k ’ ;
C [ 1 ] = ’R ’ ;
f o r ( k = 0 ; k < 4 ; k++)
printf ( "%c\n" , C [ k ] ) ;
f o r ( k = 0 ; k < 4 ; k++)
C [ k ]++;
f o r ( k = 0 ; k < 4 ; k++)
printf ( "%c\n" , C [ k ] ) ;

Exercice 2 Programme mystère

int K [ 1 0 ] , i , j ;
K [ 0 ] = 1;
f o r ( i = 1 ; i < 10 ; i++)
K [ i ] = 0;
f o r ( j = 1 ; j <= 3 ; j++)
f o r ( i = 1 ; i < 10 ; i++)
K [ i ] += K [ i − 1 ] ;
f o r ( i = 0 ; i < 10 ; i++)
printf ( "%d\n" , K [ i ] ) ;

Exercice 3 Programme mystère

int K [ 1 0 ] , i , j ;
K [ 0 ] = 1;
K [ 1 ] = 1;
f o r ( i = 2 ; i < 10 ; i++)
K [ i ] = 0;
f o r ( j = 1 ; j <= 3 ; j++)
f o r ( i = 1 ; i < 10 ; i++)
K [ i ] += K [ i − 1 ] ;
f o r ( i = 0 ; i < 10 ; i++)
printf ( "%d\n" , K [ i ] ) ;

2.4.2 Prise en main

Exercice 4 Initialisation et affichage
Ecrire un programme plaçant dans un tableau int T [10]; les valeurs 1, 2, . . . , 10, puis affichant ce tableau. Vous initia-
liserez le tableau à la déclaration.

Exercice 5 Initialisation avec une boucle

Même exercice en initialisant le tableau avec une boucle.

97
Exercice 6 somme
Affichez la somme des n éléments du tableau T .

Exercice 7 recherche
Demandez à l’utilisateur de saisir un int et dites-lui si ce nombre se trouve dans T .

2.4.3 Indices
Exercice 8 permutation circulaire
Effectuez une permutation circulaire vers la droite des éléments de T en utilisant un deuxième tableau.

Exercice 9 permutation circulaire sans deuxième tableau

Même exercice mais sans utiliser de deuxième tableau.

Exercice 10 miroir
Inversez l’ordre des éléments de T sans utiliser de deuxième tableau.

2.4.4 Recherche séquentielle

Exercice 11 modification du tableau
Etendez le tableau T à 20 éléments. Placez dans T[i] le reste modulo 17 de i2 .

Exercice 12 min/max
Affichez les valeurs du plus petit et du plus grand élément de T.

Exercice 13 recherche séquentielle

Demandez à l’utilisateur de saisir une valeur x et donnez-lui la liste des indices i tels que T[i] a la valeur x.

Exercice 14 recherche séquentielle avec stockage des indices

Même exercice que précédemment, mais vous en affichant La valeur ... se trouve aux indices suivants : ... si x se
trouve dans T, et La valeur ... n’a pas ététrouvée si x ne se trouve pas dans T.

2.4.5 Morceaux choisis

Exercice 15 pièces de monnaie
Reprennez l’exercice sur les pièces de monnaie en utilisant deux tableaux, un pour stocker les valeurs des pièces dans
l’ordre décroissant, l’autre pour stocker le nombre de chaque pièce.

Exercice 16 recherche de la tranche minimale en O(n3 )

Une tranche est délimitée par deux indices i et j tels que i ≤ j, la valeur d’une tranche est ti + . . . + tj . Ecrire
un programme de recherche de la plus petite tranche d’un tableau, vous utiliserez trois boucles imbriquées. Vous
testerez votre algorithme sur un tableau T à 20 éléments aléatoires (utilisez la fonction random de stdlib.h) de signes
quelconques.

Exercice 17 recherche de la tranche minimale en O(n2 )

Même exercice mais en utilisant deux boucles imbriquées.

98
Exercice 18 recherche de la tranche minimale en O(n) (difficile)
Même exercice mais en utilisant une seule boucle.

99
2.5 Chaînes de caractères
2.5.1 Prise en main
Exercice 1 Affichage
Créer une chaîne de caractères contenant la valeur "Les framboises sont perchees sur le tabouret de mon grand-pere."
et affichez-la avec %s. Vous donnerez au tableau la plus petite taille possible.

Exercice 2 Affichage sans %s

Même exercice mais sans utiliser %s.

Exercice 3 Longueur
Ecrire un programme saisissant proprement une chaîne de caractère (sans débordement d’indice, avec le caractère nul
et en faisant le ménage dans le buffer) et calculant sans strlen la taille de chaîne (nombre de caractères sans compter
le caractère nul).

Exercice 4 Longueur sans retour chariot

Même exercice mais en supprimant de la chaîne l’éventuel caractère de validation de la saisie (retour à la ligne).

Exercice 5 Extraction
Ecrire un programme saisissant proprement une chaîne de caractère t, deux indices i et j et recopiant dans une
deuxième chaîne t0 la tranche [ti , . . . , tj ].

Exercice 6 Substitution
Ecrire un programme saisissant proprement une chaîne de caractère t, deux caractères a et b et substituant des a à
toutes les occurrences de b.

2.5.2 Les fonctions de string . h

Pour chacun des exercices suivants, vous vous documenterez sur les fonctions de string.h utiles et vous vous en servirez
de façon convenable. Et ne faites pas de saletés !

Exercice 7 Comparaisons
Saisissez deux chaînes de caractères, déterminez la plus grande selon l’ordre lexicographique.

Exercice 8 Longueur
Saisissez deux chaînes de caractères, déterminez la plus longue des deux..

Exercice 9 Copie
Saisissez une chaîne de caractères, copiez-là dans une deuxième chaîne.

Exercice 10 Concaténation
Saisissez deux chaînes de caractères, affichez la concaténation de la première à la suite de la deuxième.

100
2.5.3 Morceaux choisis
Exercice 11 Extensions
Ecrire un programme saisissant un nom de fichier et affichant séparément le nom du fichier et l’extension. Vous prévoirez
le cas où plusieurs extensions sont concaténées, par exemple : [Link].

Exercice 12 Expressions arithmétiques

Ecrire un programme saisissant une expression arithmétique totalement parenthésée, (par exemple 3 + 4, ((3 − 2) +
(7/3))) et disant à l’utilisateur si l’expression est correctement parenthésée.

101
2.6 Fonctions
2.6.1 Géométrie
Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant un carré, une
croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne

Saisissez la taille des figures

10
* * * * * * * * * *
* *
* *
* *
* *
* *
* *
* *
* *
* * * * * * * * * *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *

102
 * *
* *

Vous définirez des sous-programmes de quelques lignes et au plus deux niveaux d’imbrication. Vous ferez attention à
ne jamais écrire deux fois les mêmes instructions. Pour ce faire, complétez le code source suivant :
#include<s t d i o . h>

/∗
Affiche le caractere c
∗/

void afficheCaractere ( char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
a f f i c h e n f o i s l e c a r a c t e r e c , ne r e v i e n t pas a l a l i g n e
apres l e dernier caractere .
∗/

void ligneSansReturn ( i n t n , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
a f f i c h e n f o i s l e caractere c , r e v i e n t a la l i g n e apres
le dernier caractere .
∗/

void ligneAvecReturn ( i n t n , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
Affiche n espaces .
∗/

void espaces ( i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
Affiche l e caractere c a l a colonne i ,
ne r e v i e n t pas a l a l i g n e a p r e s .
∗/

void unCaractereSansReturn ( i n t i , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

103
/∗
Affiche l e caractere c a l a colonne i ,
r e v i e n t a la l i g n e apres .
∗/

void unCaractereAvecReturn ( i n t i , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e l e c a r a c t e r e c aux c o l o n n e s i e t j ,
r e v i e n t a la l i g n e apres .
∗/

void deuxCaracteres ( i n t i , i n t j , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e un c a r r e de c o t e n .
∗/

void carre ( i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e un chapeau dont l a p o i n t e − non a f f i c h e e − e s t
sur l a colonne centre , avec l e s c a r a c t e r e s c .
∗/

void chapeau ( i n t centre , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e un chapeau a l ’ e n v e r s a v e c d e s c a r a c t e r e s c ,
l a p o i n t e − non a f f i c h e e − e s t a l a c o l o n n e c e n t r e
∗/

void chapeauInverse ( i n t centre , char c )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e un l o s a n g e de c o t e n .
∗/

104
void losange ( i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

/∗
A f f i c h e une c r o i x de c o t e n
∗/

void croix ( i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗∗∗∗∗∗∗∗∗∗ ∗/

main ( )
{
i n t taille ;
printf ( " Saisissez la taille des figures \n" ) ;
scanf ( "%d" , &taille ) ;
carre ( taille ) ;
losange ( taille ) ;
croix ( taille ) ;
}

2.6.2 Arithmétique
Exercice 1 chiffres et nombres
Rapellons que a \% b est le reste de la division entière de a par b.
1. Ecrire la fonction int unites(int n) retournant le chiffre des unités du nombre n.
2. Ecrire la fonction int dizaines(int n) retournant le chiffre des dizaines du nombre n.
3. Ecrire la fonction int extrait(int n, int p) retourant le p-ème chiffre de représentation décimale de n en partant
des unités.
4. Ecrire la fonction int nbChiffres(int n) retournant le nombre de chiffres que comporte la représentation décimale
de n.
5. Ecrire la fonction int sommeChiffres(int n) retournant la somme des chiffres de n.

Exercice 2 Nombres amis

Soient a et b deux entiers strictement positifs. a est un diviseur strict de b si a divise b et a 6= b. Par exemple, 3 est
un diviseur strict de 6. Mais 6 n’est pas un diviseur strict 6. a et b sont des nombres amis si la somme des diviseurs
stricts de a est b et si la somme des diviseurs de b est a. Le plus petit couple de nombres amis connu est 220 et 284.
1. Ecrire une fonction int sommeDiviseursStricts(int n), elle doit renvoyer la somme des diviseurs stricts de n.
2. Ecrire une fonction int sontAmis(int a, int b), elle doit renvoyer 1 si a et b sont amis, 0 sinon.

Exercice 3 Nombres parfaits

Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2
et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.
1. Est-ce que 18 est parfait ?
2. Est-ce que 28 est parfait ?
3. Que dire d’un nombre ami avec lui-même ?
4. Ecrire la fonction int estParfait(int n), elle doit retourner 1 si n est un nombre parfait, 0 sinon.

105
Exercice 4 Nombres de Kaprekar
Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n2 peut être séparée en une
partie gauche u et une partie droite v tel que u + v = n. 452 = 2025, comme 20 + 25 = 45, 45 est aussi un nombre
de Kaprekar. 48792 = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter
toute confusion), alors 4879 est encore un nombre de Kaprekar.
1. Est-ce que 9 est un nombre de Kaprekar ?
2. Ecrire la fonction int sommeParties(int n, int p) qui découpe n est deux nombres dont le deuxième comporte p
chiffres, et aui retourne leur somme. Par exemple,

sommeP arties(12540, 2) = 125 + 40 = 165

3. Ecrire la fonction int estKaprekar(int n)

2.6.3 Passage de tableaux en paramètre

Exercice 5 Somme
Ecrire une fonction int somme(int T [], int n) retournant la somme des n éléments du tableau T .

Exercice 6 Minimum
Ecrire une fonction int min(int T [], int n) retournant la valeur du plus petit élément du tableau T .

Exercice 7 Recherche
Ecrire une fonction int existe(int T [], int n, int k) retournant 1 si k est un des n éléments du tableau T , 0 sinon.

Exercice 8 Somme des éléments pairs

Ecrivez le corps de la fonction int sommePairs(int T[], int n), sommeP airs(T, n) retourne la somme des éléments pairs
du tableau T à n éléments. N’oubliez pas que a%b est le reste de la division entière de a par b, et que vous êtes tenu
d’utiliser au mieux les booléens.

Exercice 9 Vérification
Ecrivez le corps de la fonction int estTrie(int T[], int n), estT rie(T, n) retourne vrai si et seulement si le tableau T ,
à n éléments, est trié dans l’ordre croissant.

Exercice 10 Permutation circulaire

Ecrire une fonction void permutation(int T[], int n) effectuant une permutation circulaire vers la droite des éléments de
T.

Exercice 11 Miroir
Ecrire une fonction void miroir(int T[], int n) inversant l’ordre des éléments de T .

2.6.4 Décomposition en facteurs premiers

On pose ici N = 25, vous utiliserez un \#define N 25 dans toute cette partie. On rappelle qu’un nombre est premier
s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.
1. Ecrivez une fonction int estPremier(int n, int T [], int k) retournant 1 si n est premier, 0 sinon. Vous vérifierez
la primarité de n en examinant les restes des divisions de n par les k premiers éléments de T . On suppose que
k est toujours supérieur ou égal à 1.
√
2. Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de n inférieur à n n’a
été trouvé, alors n est premier

106
 3. Ecrivez une fonction void trouvePremiers(int T[], int n) plaçant dans le tableau T les n premiers nombres pre-
miers.
4. Ecrivez une fonction void décompose(int n, int T [], int K []) plaçant dans le tableau K la décomposition en
facteurs premiers du nombre n, sachant que T contient les N premiers nombres premiers. Par exemple, si
n = 108108, alors on décompose n en produit de facteurs premiers de la sorte

108108 = 2 ∗ 2 ∗ 3 ∗ 3 ∗ 3 ∗ 7 ∗ 11 ∗ 13 = 22 ∗ 33 ∗ 50 ∗ 71 ∗ 111 ∗ 131 ∗ 170 ∗ 190 ∗ . . . ∗ Z 0

(où Z est le N -ième nombre premier). On représente donc n de façon unique par le tableau K à N éléments

{2, 3, 0, 1, 1, 1, 0, 0, 0, . . . , 0}
5. Ecrivez une fonction int recompose(int T[], int K []) effectuant l’opération réciproque de celle décrite ci-dessus.
6. Ecrivez une fonction void pgcd(int T[], int K [], int P []) prenant en paramètre les décompositions en facteurs
premiers T et K de deux nombres, et plaçant dans P la décomposition en facteurs premiers du plus grand
commun diviseur de ces deux nombres.
7. Ecrivez une fonction int pgcd(int i, int j) prenant en paramètres deux nombres i et j, et combinant les fonctions
précédentes pour retourner le pgcd de i et j.

2.6.5 Statistiques
Nous souhaitons faire des statistiques sur les connexions des clients d’un site Web. Le tableau C, à n éléments, contient
les identifiants des clients qui se sont connectés. Ainsi C[i] contient l’identifiant du i-ème client à s’être connecté, notez
bien que si un client se connecte plusieurs fois, son identifiant apparaîtra plusieurs fois dans le tableau C. Le tableau D
contient les durées de connexion. Ainsi D[i] est le temps de connexion de la i-ème connexion. Le but est de déterminer,
pour chaque, client, son temps total de connexion.
1. Ecrire le corps du sous-programme void decalageGauche(int T[], int a, int b), ce sous-programme décale la tranche
T [a] T [a + 1] . . . T [b]
d’une case vers la gauche.
2. Ecrivez le corps de la fonction int calculeTempsTotalConnexionClient(int C[], int D[], int n, int i). calculeTempsTotalConnex
(C, D, n, i) retourne le temps total de connexion du client d’identifiant C[i], on suppose que i est l’indice de la
première occurence de C[i] dans C.
3. Ecrivez le corps de la fonction int supprimeDoublons(int C[], int D [], int n, int i). supprimeDoublons(C, D, n, i)
supprime toutes les occurences (d’indices strictement supérieurs à i) du client d’identifiant C[i] dans C et D et
retourne le nombre d’éléments supprimés. Vous devrez utiliser decalageGauche.
4. Ecrivez le corps de la fonction int tempsTotalDeConnexion(int C[], int D[], int n, int i). tempsTotalDeConnexion(
C, D, n,i) place dans D[i] le temps total de connexion du client C[i] et élimine de C et de D toutes les autres
occurences de ce client. Cette fonction doit retourner le nombre d’éléments supprimés. Vous devrez utiliser
calculeTempsTotalConnexionClient et supprimeDoublons.
5. Ecrire le corps du sous-programme inttempsTotauxDeConnexion(int C[], int D[], int n). tempsTotauxDeConnexion(C
, D, n) additionne les temps de connexions de chaque visiteur. Vous devrez modifier C et D de sorte que chaque
client n’apparaîsse qu’une fois dans C et que D contienne pour chaque client son temps total. Cette fonction
retourne le nombre d’éléments significatifs dans C et D. Vous devrez utiliser tempsTotalDeConnexion.

2.6.6 Chaînes de caractères

Exercice 12 affichage
Ecrivez une fonction void afficheChaine(char s[]) qui affiche la chaîne de caractère s sans utiliser de %s.

Exercice 13 longueur
Ecrivez une fonction int longueur(char s[]) qui retourne la longueur de la chaîne de caractère s sans utiliser strlen.

107
Exercice 14 extraction
Ecrivez une fonction char extrait(char s[], int n) qui retourne le n-ème caractère de s, vous considérerez que les indices
commencent à 1.

Exercice 15 substitution
Ecrivez une fonction void subs(char s[], int n, char a) qui remplace le n-ème caractère de s par a, vous considérerez
que les indices commencent à 1.

2.6.7 Programmation d’un Pendu

Cette section a pour but la programmation d’un pendu, vous êtes invités à utiliser les fonctions définies ci-dessus.

Exercice 16 initialisation
Ecrire une fonction void initialise(char t[], int n) qui place dans t n caractères ’\_’.

Exercice 17 vérification
Ecrire une fonction void verifie(char t[], char k[], char c) qui recherche toutes les occurences du caractère c dans t,
soit i l’indice d’une occurrence de c dans t, alors cette fonction remplace le i-ème caractère de k par c. Par exemple,
si on invoque verifie(‘‘bonjour", ‘‘b\_\_j\_\_r", ’o’), alors k prendra la valeur "bo\_jo\_r’’.

Exercice 18 Le jeu
Programmez un pendu, faites le plus simplement possible, et utilisez les fonctions ci-dessus..

2.6.8 Tris
Exercice 19 Tri à bulle
1. Ecrivez le corps de la fonction void echange(int T[], int a, int b), echange(T, a, b) échange les éléments T [a] et
T [b].
2. Ecrivez le corps de la fonction void ordonne(int T[], int a, int b), ordonne(T, a, b) échange les éléments T [a] et
T [b] si T [a] > T [b]. Vous utliserez le sous-programme echange.
3. Ecrivez le corps de la fonction void bulle(int T[], int a, int b), bulle(T, a, b) place le plus grand élément de la
tranche T [a] T [a + 1] . . . T [b] dans T [b]. Vous utiliserez le sous-programme ordonne.
4. Ecrivez le corps de la fonction void triBulle(int T[], int n), triBulle(T, n) tri le tableau T à n éléments. Vous
utiliserez le sous-programme bulle.

Exercice 20 Tri par sélection

1. Implémentez la fonction int indiceDuMin(int T[], int i, int j) retournant l’indice du plus petit élément de T(i)
, ..., T(j), c’est-à-dire de tous les éléments du tableau dont l’indice est compris entre i et j.
2. Implémentez le sous-programme void placeMin(int T[], int i, int j, int k) échangeant avec T(k) le plus petit
élément de T dont l’indice est compris entre i et j.
3. Le tri par sélection est une méthode consistant à rechercher dans un tableau T à n éléments le plus petit élément
du tableau et à l’échanger avec le T (1). Puis à chercher dans T (2), . . . , T (N ) le deuxième plus petit élément et
à l’échanger avec T (2), etc. Une fois un tri par sélection achevé, les éléments du tableau doivent être disposés
par ordre croissant. Ecrivez le sous-programme void triParSelection(int T[], int N).

108
2.7 Structures
2.7.1 Prise en main
Exercice 1
Créez un type structuré st contenant un char appelé c et un int appelé i.

Exercice 1
Créez deux variables k et l de type st. Affectez-leur les valeurs (0 a0 , 1) et (0 b0 , 2).

Exercice 1
Affichez les valeurs de tous les champs de ces deux variables.

2.7.2 Heures de la journée

Nous utiliserons pour représenter des heures de la journée au format hh : mm le type
typedef struct
{
i n t heure ;
i n t minute ;
} heure_t ;

Le champ heure devra contenir une valeur de {0, 1, . . . , 11} et le champ minute une valeur de {0, 1, 2, . . . , 59}. Complétez
le code source suivant :
#include<s t d i o . h>

typedef struct
{
i n t heure ;
i n t minute ;
} heure_t ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Retourne uen s t r u c t u r e i n i t i a l i s e e a v e c l e s
v a l e u r s h e u r e s e t m inutes .
∗/

heure_t creerHeure ( i n t heures , i n t minutes )

{
heure_t result = { 0 , 0 } ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
C o n v e r t i t t en mi nutes .
∗/

i n t enMinutes ( heure_t t )
{
return 0 ;
}

109
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
C o n v e r t i t l a d u r e e t en heure_t .
∗/

heure_t enHeures ( i n t t )
{
heure_t result = { 0 , 0 } ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
A f f i c h e x au f o r m a t hh :mm
∗/

void afficheHeure ( heure_t x )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Additionne a et b .
∗/

heure_t additionneHeures ( heure_t a , heure_t b )

{
heure_t result = { 0 , 0 } ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Retourne l a v a l e u r a a j o u t e r a x pour o b t e n i r 0 0 : 0 0 .
∗/

heure_t inverseHeure ( heure_t x )

{
heure_t result = { 0 , 0 } ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Soustrait b a a.
∗/

heure_t soustraitHeures ( heure_t a , heure_t b )

{
heure_t result = { 0 , 0 } ;
return result ;
}

110
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Retourne 1 s i a > b , −1 s i a < b , 0 s i a = b .
∗/

i n t compareHeures ( heure_t a , heure_t b )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Retourne l a p l u s p e t i t e d e s h e u r e s a e t b .
∗/

heure_t minHeure ( heure_t a , heure_t b )

{
heure_t result = { 0 , 0 } ;
return result ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗ ∗/

/∗
Pour t e s t e r l e s f o n c t i o n s . . .
∗/

i n t main ( )
{
return 0 ;
}

2.7.3 Répertoire téléphonique

Nous considérons les déclarations suivantes :
#include<s t d i o . h>
#include<s t d l i b . h>
#include<s t r i n g . h>

#define TAILLE_NOM 50
#define TAILLE_TEL 10
#define NB_MAX_NOMS 500

struct personne
{
char nom [ TAILLE_NOM + 1 ] ;
char tel [ TAILLE_TEL + 1 ] ;
};

Il vous est demandé de programmer un répertoire télphonique en stockant les entrées du répertoire dans un tableau
de structpersonne. Les entrées devront être triées, il devra être possible de rechercher des entrées avec le préfixe du
nom, insérer et supprimer des entrées. Prévoyez aussi la possibilité d’afficher toutes les entrées du répertoire les unes
à la suite des autres. Bon courage.

111
2.8 Pointeurs
2.8.1 Aliasing
Exercice 1
Ecrivez un programme déclarant une variable i de type int et une variable p de type pointeur sur int. Affichez les
dix premiers nombres entiers en :
— n’incrémentant que i
— n’affichant que ∗p

Exercice 2
Même exercice en
— n’incrémentant que ∗p
— n’affichant que i

Exercice 3
Déterminez ce qu’affiche ce programme, exécutez-ensuite pour vérifier.
#include<s t d i o . h>

main ( )
{
int i = 4 ;
int j = 1 0 ;
int ∗ p ;
int ∗ q ;
p = &i ;
q = &j ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
∗p = ∗p + ∗q ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
p = &j ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
∗q = ∗q + ∗p ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
q = &i ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
i = 4;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
∗q = ∗q + 1 ;
printf ( "i = %d , j = %d , p = %d , q = %d\n" , i , j , ∗p , ∗q ) ;
}

2.8.2 Tableaux
Exercice 4 prise en main
Ecrire un programme qui place dans un tableau t les N premiers nombres impairs, puis qui affiche le tableau. Vous
accéderez à l’élément d’indice i de t avec l’expression ∗(t + i).

Exercice 5 Tri à bulle

Ecrire un sous-programme triant un tableau t avec la méthode du tri à bulle. Vous accéderez à l’élément d’indice
i de t avec l’expression ∗(t + i).

112
2.8.3 Exercices sans sous-programmes
Exercice 6 Tableaux de carrés
Ecrire un programme qui demande à l’utilisateur de saisir un nombre n, et qui place les n premiers nombres impairs
dans un tableau t. Utilisez ensuite le fait que k 2 est la somme des k premiers nombres impairs pour calculer puis
afficher les n premiers nombres carrés.

Exercice 7 Matrices et pointeurs de pointeurs

Ecrivez un programme qui demande à l’utilisateur de saisir un nombre n et qui crée une matrice T de dimensions
n × n avec un tableau de n tableaux de chacun n éléments. Nous noterons tij le j-ème élément du i-ème tableau. Vous
initialiserez T de la sorte : pour tous i, j, tij = 1 si i = j (les éléments de la diagonale) et tij = 0 si i 6= j (les autres
éléments). Puis vous afficherez T .

Exercice 8 Copie de chaînes de caractères

Ecrivez un programme qui saisit proprement une chaîne de caractère s et qui la recopie dans un tableau crée avec
malloc et de contenance correspondant exactement à la longueur de s. Vous n’utiliserez ni strlen, ni strcpy.

Exercice 9 Tableau de chaînes

Reprennez le programme précédent en saissisant successivement 4 chaînes de caractères et en les stockant dans un
tableau de chaînes de caractères.

2.8.4 Allocation dynamique

Exercice 10 Prise en main
Créez dynamiquement un int, affectez-y la valeur 5, affichez-le, libérez la mémoire.

Exercice 11 Tableaux sur mesure

Demandez à l’utilisateur la taille du tableau qu’il souhaite créer, allouez dynamiquement l’espace nécessaire et
placez-y les valeurs {0, . . . n − 1}, affichez-le et libérez la mémoire.

2.8.5 Pointeurs et pointeurs de pointeurs

Exercice 12 Tableaux sur mesure
Qu’affiche le programme suivant :
#include<s t d i o . h>

i n t main ( )
{
long A , B , C , D ;
long ∗p1 , ∗p2 , ∗ p3 ;
long ∗∗ pp ;
A = 10 ;
B = 20 ;
C = 30 ;
D = 40;
p1 = &A ;
p2 = &B ;
p3 = &B ;
∗ p1 = ( ∗ p1 + 1 ) ;
∗ p3 = ( ∗ p2 + D ) ;
p3 = &C ;
∗ p3 = ( ∗ p2 + D ) ;

113
 printf ( "A = %ld , B = %ld , C = %ld , D = % ld \n" , A , B , C , D ) ;
pp = &p3 ;
printf ( "% ld \n" , ∗∗ pp ) ;
return 0 ;
}

2.8.6 Passages de paramètres par référence

Exercice 13
Déterminez ce qu’affiche ce programme, exécutez-ensuite pour vérifier.
#include<s t d i o . h>

void affiche2int ( i n t a , i n t b )
{
printf ( "%d , %d\n" , a , b ) ;
}

void incr1 ( i n t x )
{
x = x + 1;
}

void incr2 ( i n t ∗ x )
{
∗x = ∗x + 1 ;
}

void decr1 ( i n t ∗ x )
{
x = x − 1;
}

void decr2 ( i n t ∗ x )
{
∗x = ∗x − 1 ;
}

i n t main ( )
{
int i = 1 ;
int j = 1 ;
affiche2int ( i , j) ;
incr2(&i ) ;
affiche2int ( i , j) ;
decr1(&j ) ;
affiche2int ( i , j) ;
decr2(&j ) ;
affiche2int ( i , j) ;
while ( i != j )
{
incr1 ( j ) ;
decr2(&i ) ;
}
affiche2int ( i , j) ;
return 0 ;
}

114
Exercice 14
Ecrivez le corps du sous-programme additionne, celui-ci doit placer dans res la valeur i + j.
#include<s t d i o . h>

void additionne ( i n t a , i n t b , i n t ∗ res )

{
/∗ E c r i v e z l e c o r p s du sous−programme i c i ∗/

i n t main ( )
{
int i = 2 ;
int j = 3 ;
int k ;
additionne ( i , j , &k ) ;
printf ( "k = %d\n" , k ) ; // d o i t a f f i c h e r " k = 5"
return 0 ;
}

Exercice 15
Ecrivez le sous-programme void puissance(int b, int n, int∗ res), qui place dans la variable pointée par res le ré-
sultat de bn .

Exercice 16
Ecrivez le sous-programme void tri(int∗ a, int∗ b, int∗\ c) qui permute les valeurs de ∗a, ∗b et ∗c de sorte que
∗a ≤ ∗b ≤ ∗c. Vous utiliserez le sous-programme void echange(int∗ x, int∗ y).

2.8.7 Les pointeurs sans étoile

Le but de cet exercice est d’encapsuler les accès à la mémoire par le biais des pointeurs dans des fonctions. Ecrivez
le corps des fonctions suivantes :
1. int getIntVal(int∗ p) retourne la valeur se trouvant à l’adresse p.
2. void setIntVal(int∗ p, int val) affecte la valeur val à la variable pointée par p.
3. int∗ getTiAdr(int∗ t, int i) retourne l’adresse de l’élément T [i]
4. int getTiVal(int∗ t, int i) retourne la valeur de l’élément T [i], vous utiliserez getTiAdr et getIntVal
5. void setTiVal(int∗ t, int i, int val) affecte à T [i] la valeur val, vous utiliserez getTiAdr et setIntVal.
6. void swapInt(int∗ a, int∗ b) échange les valeurs des variables pointées par a et b. Vous utiliserez getIntVal et
setIntVal.
7. void swapTij(int∗ t, int i, int j) échange les valeurs T [i] et T [j], vous utiliserez swapInt et getTiAdr.
Ecrivez le corps de la fonction de tri void sort(int∗ t, int n) de votre choix en utilisant au mieux les fonctions
ci-dessus.

2.8.8 Tableau de tableaux

Le but de cet exercice est de créer n tableaux de chacun m éléments, de placer les n pointeurs ainsi obtenus dans
un tableau de pointeurs T de type int ∗ ∗ et de manier T comme un tableau à deux indices. Ecrivez les corps des
fonctions suivantes :
1. int∗∗ getTi_Adr(int∗∗ T, int i) retourne l’adresse du pointeur vers le i-ème tableau d’int de T .
2. int∗ getTi_(int∗∗ T, int i) retourne le i-ème tableau d’int de T , vous utiliserez getTi_Adr.

115
 3. void setT__Adr(int∗∗ T, int∗ p) place dans la variable pointée par T le pointeur p.
4. void setTi_(int∗∗ T, int i, int∗ p) fait de p le i-ème tableau de T , vous utiliserez getT__Adr et setTi_Adr
5. void createT__(int∗∗ T, int n, int m) fait pointer chacun des n éléments de T vers un tableau à m éléments. Vous
utiliserez setTi_Adr.
Nous noterons Tij le j-ème élément du tableau T [i]. Pour tous (i, j) ∈ {1, . . . , 10}2 , le but est de placer dans tij la
valeur 10i + j. Vous utiliserez les fonctions int getIntVal(int∗ p), void setIntVal(int∗ p, int val), int∗ getTiAdr(int∗
t, int i), int getTiVal(int∗ t, int i) et void setTiVal(int∗ t, int i, int val) pour écrire les corps des sous-programmes
ci-dessous :
1. int∗ getTijAdr(int∗∗ t, int i, int j) retourne l’adresse de Tij
2. int getTijVal(int∗∗ t, int i, int j) retourne la valeur de Tij
3. void setTijVal(int∗∗ t, int i, int j, int val) affecte à Tij la valeur val.

2.8.9 Triangle de Pascal

En utilisant les sous-programmes ci-dessus, ecrire un programme qui demande à l’utilisateur un nombre n, puis
qui crée un triangle de Pascal à n + 1 lignes, et qui pour finir affiche ce triangle de Pascal. Vous utiliserez les sous-
programmes définis dans les questions précédentes et rédigerez des sous-programmes les plus simples possibles (courts,
le moins d’étoiles possible).

2.8.10 Pointeurs et récursivité

Vous rédigerez toutes les fonctions suivantes sous forme itérative, puis récursive.
1. Ecrire une fonction void initTab(int∗ t, int n) plaçant dans le tableau t les éléments 1, 2, . . . , n.
2. Ecrire une fonction void printTab(int∗ t, int n) affichant les n éléments du tableau t.
3. Ecrire une fonction int sommeTab(int∗ t, int n) retournant la somme des n éléments du tableau t.
4. Ecrire une fonction (ni récursive, ni itérative) void swap(int∗ t, int i, int j) échangeant les éléments d’indices
i et j du tableau t.
5. Ecrire une fonction void mirrorTab(int∗ t, int n) inversant l’ordre des éléments du tableau t.
6. Ecrire une fonction int find(int∗ t, int n, int x) retournant 1 si x se trouve dans le tableau t à n éléments, 0
sinon.
7. Ecrire une fonction int distinctValues(int∗ t, int n) retournant le nombre de valeurs distinctes du tableau t à
n éléments. Le nombre de valeurs distinctes s’obtient en comptant une seule fois chaque valeur du tableau si
elle apparaît plusieurs fois. Par exemple, les valeurs distinctes de {1, 2, 2, 3, 9, 4, 3, 7} sont {1, 2, 3, 4, 7, 9} et il y
en a 6.
En utilisant les exercices sur les heures dans la section structures, vous rédigerez les fonctions suivantes sous forme
récursive.
1. Ecrire une fonction void afficheTabHeures(heure_t∗ t, int n) affichant les n heures de t.
2. Ecrire une fonction void initTabHeures(heure_t∗ t, int n, heure_t depart, heure_t pas) initialisant le tableau t
à n éléments comme suit : la première heure est depart et chaque heure s’obtient à additionnant pas à la
précédente.
3. Ecrire une fonction heure_t sommeTabHeures(heure_t∗ t, int n) retournant la somme des n heures du tableau t.
4. Ecrire une fonction heure_t minTabHeure(heure_t∗ t, int n) retournant la plus petite des n heures du tableau t.

2.8.11 Tri fusion

Complétez le code suivant :

116
#include<s t d i o . h>
#include<s t d l i b . h>
#include<time . h>

#define MOD 10000

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
A f f i c h e l e s n e l e m e n t s du t a b l e a u t .
∗/

void printTab ( i n t ∗ t , i n t n )
{
i f ( n > 0)
{
printf ( "%d " , ∗t ) ;
printTab ( t + 1 , n − 1 ) ;
}
else
printf ( "\n" ) ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
P l a c e n e l e m e n t s a l e a t o i r e s de v a l e u r s maximales
MOD − 1 dans l e t a b l e a u t .
∗/

void initTab ( i n t ∗ t , i n t n )
{
i f ( n > 0)
{
∗t = rand ( )%MOD ;
initTab ( t + 1 , n − 1 ) ;
}
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
Retourne un t a b l e a u de n
e l e m e n t s a l l o u e dynamiquement .
∗/

i n t ∗ createTab ( i n t n )
{
i n t ∗ t = ( i n t ∗ ) malloc ( s i z e o f ( i n t ) ∗n ) ;
i f ( t == NULL )
{
printf ( " no memory avalaible \n" ) ;
exit ( 0 ) ;
}
return t ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

117
/∗
L i b e r e l a zone memoire p o i n t e e par ∗ t
e t met ce p o i n t e u r a NULL.
∗/

void destroyTab ( i n t ∗∗ t )
{
free ( ∗ t ) ;
∗t = NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
( Recursive )
Retourne l ’ i n d i c e du p l u s p e t i t
e l e m e n t du t a b l e a u t a n e l e m e n t s .
A f f i c h e une e r r e u r s i l e t a b l e a u e s t v i d e .
∗/

i n t indexOfMin ( i n t ∗ t , i n t n )
{
return 0 ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
Echange l e s e l e m e n t s ∗ x e t ∗ y .
∗/

void swap ( i n t ∗ x , i n t ∗ y )
{
i n t temp = ∗x ;
∗x = ∗y ;
∗y = temp ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
Echange l e p l u s p e t i t e l e m e n t du t a b l e a u
t a n elements avec l e premier .
∗/

void swapMin ( i n t ∗ t , i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
( Recursive )
Trie l e t a b l e a u t a n elements avec l a
methode du t r i par s e l e c t i o n .
∗/

void selectionSort ( i n t ∗ t , i n t n )
{

118
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
( Recursive )
Recopie l e s n e l e m e n t s du t a b l e a u s o u r c e
a l ’ adresse dest .
∗/

void copyTab ( i n t ∗ source , i n t ∗ dest , i n t n )

{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
( Recursive )
I n t e r c l a s s e l e s n1 e l e m e n t s de s o u r c e 1 a v e c l e s n2 e l e m e n t s de s o u r c e 2 .
source1 et source2 sont supposes t r i e s . L ’ interclassement se f a i t
en d i s p o s a n t c e s e l e m e n t s dans l ’ o r d r e dans l e t a b l e a u d e s t .
∗/

void shuffleTab ( i n t ∗ source1 , i n t ∗ source2 , i n t ∗ dest ,

i n t n1 , i n t n2 )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
T r i e l e s n e l e m e n t s de t a v e c l a methode du t r i f u s i o n .
∗/

void fusionSort ( i n t ∗ t , i n t n )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
Compare l e s p e r f o r m a n c e s en temps de c a l c u l
d e s t r i s par s e l e c t i o n e t par f u s i o n .
∗/

i n t compareSorts ( i n t firstValue , i n t lastValue , i n t step )

{
int i ;
i n t start , stop ;
i n t ∗t , ∗q ;
srand ( time ( NULL ) ) ;
f o r ( i = firstValue ; i <= lastValue ; i += step )
{
printf ( " with %d elements : \n" , i ) ;
t = createTab ( i ) ;
q = createTab ( i ) ;
initTab ( t , i ) ;
copyTab ( t , q , i ) ;
start = time ( NULL ) ;

119
 selectionSort ( t , i ) ;
stop = time ( NULL ) ;
printf ( "* selection sort : %d\n" , stop − start ) ;
destroyTab(&t ) ;
start = time ( NULL ) ;
fusionSort ( q , i ) ;
stop = time ( NULL ) ;
printf ( "* fusion sort : %d\n" , stop − start ) ;
destroyTab(&q ) ;
}
return 0 ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗∗ ∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗∗∗∗ ∗∗∗ ∗/

/∗
Pour t e s t e r l e s f o n c t i o n s au f u r e t a mesure qu ’ e l l e s s o n t
ecrites . . .
∗/

i n t main ( )
{
compareSorts ( 1 0 0 0 0 , 5 0 0 0 0 0 , 1 0 0 0 ) ;
return 0 ;
}

120
2.9 Fichiers
2.9.1 Ouverture et fermeture
Exercice 1 touch
La commande shell touch permet de créer un fichier vide. Ecrire un programme prenant le nom d’un fichier en ligne
de commande et le créant.

2.9.2 Lecture
Exercice 2 more
La commande shell more permet d’afficher le contenu d’un fichier. Ecrire un programme prenant le nom d’un fichier
en ligne de commande et affichant son contenu.

2.9.3 Ecriture
Exercice 3 Alphabet
Ecrire un programme C alphabet permettant de créer un fichier. Le nom du fichier crée sera passé en ligne de
commande et le fichier contiendra l’alphabet.

Exercice 4 Initialiser un fichier

Ecrire un programme C createFile permettant de créer un fichier. Le nom du fichier crée sera le premier des
arguments, tous les arguments suivants seront écrits dans le fichier. Par exemple, la commande ./createFile [Link]
ceci est le contenu de mon fichier doit créer un fichier appelé [Link] et contenant le texte

ceci est le contenu de mon fichier

2.9.4 Lecture et écriture

Exercice 5 cp
La commande shell cp permet d’afficher le contenu d’un fichier. Ecrire un programme prenant en ligne de commande
le nom d’un fichier source et celui d’un fichier de destination, et recopiant le contenu du fichier source dans celui de
destination.

Exercice 6 Liste de noms

Ecrire deux programmes storeNames et getNames. storeNames demande à l’utilisateur de saisir une liste de noms et
les enregistre au fur et à mesure qu’ils sont saisis dans un fichier dont le nom a été passé en ligne de commande au
lancement du programme. On arrête le programme en saisissant −1. getNames affiche la liste des noms stockée dans le
fichier dont le nom est passé en ligne de commande.

2.9.5 Enigma
Compléter le fichier source suivant :
#include<s t d i o . h>
#include<s t d l i b . h>

#define NB_ROTORS 5
#define NB_LETTERS 26

#define FORWARD 1
#define BACKWARD 2

121
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

typedef struct rotor

{
char permutation [ NB_LETTERS ] ;
char permutationInverse [ NB_LETTERS ] ;
char position ;
} rotor ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

typedef struct enigma

{
rotor rotors [ NB_ROTORS ] ;
char mirror [ NB_LETTERS ] ;
} enigma ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
D i s p o s e t o u s l e s r o t o r s dans l e u r p o s i t i o n de d e p a r t .
∗/

void initialiseRotors ( enigma ∗ e )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
L i b e r e l a memoire o c c u p e e par e .
∗/

void enigmaDestroy ( enigma ∗ e )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
A l l o u e l a memoire e t i n i t i a l i s e l e s champs .
∗/

enigma ∗ enigmaCreate ( )
{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
Retourne l e rang de l e t t e r dans l ’ a l p h a b e t , en i n d i c a n t
a p a r t i r de 0 .
∗/

char indexOfLetter ( char letter )

{
return 0 ;
}

122
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
Retourne l a l e t t r e d ’ i n d i c e i n d e x dans l ’ a l p h a b e t ,
’a ’ est d ’ indice 0.
∗/

char letterOfIndex ( char index )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
F a i t de l a l e t t r e c i p h e r L e t t e r l ’ image de l a l e t t r e
d ’ i n d i c e c l e a r I n d e x par un p a s s a g e dans l e r o t o r d ’ i n d i c e r o t o r I n d e x
de e .
∗/

void setImage ( enigma ∗ e , i n t rotorIndex , i n t clearIndex , char cipherLetter )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
F a i t de f i r s t L e t t e r l e r e f l e t de s e c o n d L e t t e r .
∗/

void setMirror ( enigma ∗ e , char firstLetter , char secondLetter )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
Retourne v r a i s i e t s e u l e m e n t s i l e t t e r e s t une m i n u s c u l e
de l ’ a l p h a b e t .
∗/

i n t isEncryptable ( char letter )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
A f f i c h e l e s r o t o r s e t l e m i r o i r de e .
∗/

void enigmaPrint ( enigma ∗ e )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

123
/∗
F a i t p i v o t e r l e r o t o r d ’ i n d i c e i n d e x O f R o t o r de e
en m o d i f i a n t sa p o s i t i o n de d e p a r t . Retourne
v r a i s s i l e r o t o r e s t r e v e n u dans sa p o s i t i o n
initiale .
∗/

i n t rotateRotor ( enigma ∗ e , i n t indexOfRotor )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
F a i t p i v o t e r l e j e u de r o t o r s de e d ’ une p o s i t i o n .
∗/

void rotateRotors ( enigma ∗ e )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
I n d i c e d ’ e n t r e e de l a l e t t r e d ’ i n d i c e i n d e x O f L e t t e r
dans l e r o t o r r , en t e n a n t compte de l a p o s i t i o n de
ce r o t o r .
∗/

i n t inputIndex ( rotor ∗ r , i n t indexOfLetter )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
I n d i c e de l a l e t t r e s o r t i e a l ’ i n d i c e i n d e x O f L e t t e r
du r o t o r r , en t e n a n t compte de l a p o s i t i o n de
ce r o t o r .
∗/

i n t outputIndex ( rotor ∗ r , i n t indexOfLetter )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
F a i t p a s s e r l a l e t t r e d ’ i n d i c e i n d e x O f L e t t e r dans r
dans l a d i r e c t i o n d i r e c t i o n (FORWARD ou BACKWARD) .
∗/

i n t rotorEncrypt ( rotor ∗ r , i n t indexOfLetter , char direction )

{
return 0 ;
}

124
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
F a i t p a s s e r l a l e t t r e d ’ i n d i c e i n d e x O f L e t t e r dans
l e m i r o i r de e .
∗/

i n t mirrorEncrypt ( enigma ∗ e , i n t indexOfLetter )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
C h i f f r e l e t t e r avec e , f a i t e n s u i t e p i v o t e r l e s r o t o r s
de e . .
∗/

char enigmaEncrypt ( enigma ∗ e , char letter )

{
return 0 ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
C h i f f r e l e f i c h i e r clearFName a v e c e , e c r i t l e r e s u l t a t
dans cipherFName .
∗/

void encryptFile ( enigma ∗ e , char∗ clearFName , char∗ cipherFName )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
I n i t i l i a l i s e l e s NB_ROTORS r o t o r s de e a v e c deux
e c r i t s dans l e f i c h i e r r o t o r s .
∗/

void loadRotors ( enigma ∗ e , FILE ∗ rotors )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
Initilialise l e m i r o i r de e a v e c une l i g n e du f i c h i e r r o t o r s .
∗/

void loadMirror ( enigma ∗ e , FILE ∗ rotors )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

125
/∗
Cree une machine enigma i n i t i a l i s e e a v e c l e conten u du f i c h i e r
rotorFileName .
∗/

enigma ∗ loadFile ( char∗ rotorFileName )

{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

/∗
C h i f f r e l e f i c h i e r c l e a r a v e c l a machine enigma
d e c r i t e dans r o t o r s , e c r i t l e r e s u l t a t dans c i p h e r .
∗/

void enigmaRun ( char∗ clear , char∗ cipher , char∗ rotors )

{
enigma ∗ e = loadFile ( rotors ) ;
encryptFile ( e , clear , cipher ) ;
enigmaDestroy ( e ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗∗∗ ∗∗ ∗∗∗ ∗/

i n t main ( i n t argc , char∗ argv [ ] )

{
i f ( argc == 4 )
enigmaRun ( argv [ 1 ] , argv [ 2 ] , argv [ 3 ] ) ;
else
printf ( " usage : ./ enigma source cipher rotorfile \n " ) ;
return 0 ;
}

klmnopqvwxyzgabcdefhijrstu
uvwxystzabcdejklmnopqrfghi
klmnopqabcdvwxyzgstuefhijr
zgabcdefklmnopqvhijrstuwxy
tuklmnopqvwxyzgabcdefhijrs
wzgabchijrmdefynopqvstuklx

Que contient le message suivant ? (attention, les accents s’affichent mal...)

Bobuq , uynl myck ipyvp z é mjb é lr lpkn zvw eywbovtssi !

126
2.10 Matrices
Exercice 1 identite
Ecrire une fonction initialisant une matrice identite d’ordre n.

Exercice 2 somme
Ecrire une fonction calculant la somme de deux matrices.

Exercice 3 transposition
Ecrire une fonction calculant la matrice transposée d’une matrice N × M passée en paramètre.

Exercice 4 produit
Ecrire une fonction calculant le produit de deux matrices N × M et M × P passées en paramètre.

Exercice 5 triangle de Pascal

Un triangle de Pascal peut être placé dans une matrice contenant des 1 sur la première colonne et la diagonale, et
tel que chaque élément m[i][j] de la matrice soit la somme des éléments m[i − 1][j − 1] et m[i − 1][j]. Seule la partie
triangulaire inférieure d’un triangle de Pascal contient des valeurs significatives. Ecrire une fonction initialisant un
triangle de Pascal à n lignes.

Exercice 6 Matrice marrante

Ecrire une fonction plaçant dans chaque emplacement d’indices (i, j) d’une matrice la valeur (i + 1)j . Vous utiliserez
le fait que
(i + 1)j = P (0, j)i0 + P (1, j)i1 + P (1, j)i1 + . . . + P (k, j)ik + . . . + P (j, j)ij
où P (a, b) est l’élément se trouvant à la colonne a et à la ligne b du triangle de Pascal.

127
2.11 Initiation à la récursivité
2.11.1 Sous-programmes récursifs
Tous les sous-programmes dans les exercices ci-dessous doivent être rédigés de façon récursive, ils ne doivent pas
contenir de boucle.

Exercice 1 Compte à rebours

Écrire une procédure affichant un compte à rebours en partant du nombre passé en paramètre.

Exercice 2 Somme
Écrire une fonction retournant la somme de deux nombres entiers positifs passés en paramètre sans les additionner.
Vous n’utiliserez que des incrémentations et des décrémentations.

Exercice 3 Factorielle
Écrire une fonction retournant la factorielle du nombre passé en paramètre.

Exercice 4 Produit
Écrire une fonction retournant le produit de deux nombres entiers passés en paramètre sans les multiplier.

Exercice 5 Série arithmétique

Écrire une fonction retournant la somme des n premiers entiers (où n est passé en paramètre).

Exercice 6 Puissance
Écrire une fonction retournant bn (où b et n sont tous deux passés en paramètre).

Exercice 7 Nombre de chiffres

Écrire une fonction retournant le nombre de chiffres d’un entier n passé en paramètre. Ne pas convertir le nombre
en chaîne de caractères !

Exercice 8 p-ème chiffre

Écrire une fonction retournant le p-ième chiffre d’un entier n en partant de la droite. Si par exemple n = 13489765123
et p = 4, alors la fonction retourne 5 car il s’agit du 4 chiffre de n en partant des unités.

Exercice 9 Somme des chiffres

Écrire une fonction retournant la somme des chiffres d’un entier n passé en paramètre.

2.11.2 Morceaux choisis

Exercice 10 Recherche par dichotomie
Écrire une fonction recherche(t[], x, i, j : entier) : booleen retournant vrai si et seulement si il existe un élément du
tableau t qui soit égal à x et dont l’indice se trouve entre i et j. On suppose que le tableau t est trié.

Exercice 11 Suite de Fibonacci

Écrire une fonction permettant de calculer le n-ème terme de la suite de Fibonacci définie par u0 = 0, u1 = 1 et
un = un−1 + nn−2 . Est-ce efficace pour de grandes valeurs de n ? Est-il possible de rédiger un algorithme itératif ayant
de meilleures performances ?

128
Exercice 12 Tri fusion
Écrire une procédure appliquant la méthode du tri fusion à un tableau passé en paramètre.

Exercice 13 Belle marquise...

Écrire une procédure affichant toutes les permutations de Belle marquise, vos beaux yeux me font mourir d’amour.

129
2.12 Listes Chaînées
2.12.1 Pointeurs et structures
Exercice 1
Créer un type st contenant un champ i de type int et un champ c de type char. Déclarez une variable p de type st∗,
allouez dynamiquement une variable de type st et faites pointer p dessus. Affectez à cette variable les valeurs 5 et ’a’.
Affichez-les, libérez la mémoire.

2.12.2 Maniement du chaînage

Exercice 1 prise en main
Etant donné le programme
#include<s t d i o . h>

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct maillon

{
i n t data ;
struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon m , p ;
maillon ∗ ptr ;
m . data = 1 ;
m . next = &p ;
p . data = 2 ;
p . next = NULL ;
f o r ( ptr = &m ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
return 0 ;
}

Reprennez ce programme : créez deux maillons q et r en renseignant les champ data aux valeurs respectives 3 et 4,
renseignez les valeurs next des maillons de sorte que la boucle f or affiche

data = 1
data = 2
data = 3
data = 4

Exercice 2 tableaux
Reprennez le programme
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

130
typedef struct maillon
{
i n t data ;
struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void printData ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
maillon ∗ l ;
int i ;
l = ( maillon ∗ ) malloc ( N ∗ s i z e o f ( maillon ) ) ;
i f ( l == NULL )
return −1;
l−>data = 0 ;
f o r ( i = 1 ; i < N ; i++)
{
( l + i )−>data = i ;
( l + i − 1 )−>next = l + i ;
}
( l + N − 1 )−>next = NULL ;
printData ( l ) ;
free ( l ) ;
return 0 ;
}

Modifiez le chaînage de sorte que les maillons soient disposés dans l’ordre inverse et que, par conséquent, ce programme
affiche :

data = 9
data = 8
data = 7
data = 6
data = 5
data = 3
data = 4
data = 2
data = 1
data = 0

2.12.3 Opérations sur les listes chaînées

Pour les exercices suivants, vous utiliserez ce fichier source :
#include<s t d i o . h>
#include<s t d l i b . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

131
typedef struct maillon
{
i n t data ;
struct maillon ∗ next ;
} maillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void printLL ( maillon ∗ ptr )

{
f o r ( ; ptr != NULL ; ptr = ptr−>next )
printf ( " data = %d\n" , ptr−>data ) ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ creeMaillon ( i n t n )
{
maillon ∗ l ;
l = ( maillon ∗ ) malloc ( s i z e o f ( maillon ) ) ;
i f ( l == NULL )
exit ( 0 ) ;
l−>data = n ;
l−>next = NULL ;
return l ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ insereFinLL ( maillon ∗ l , i n t n )

{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ copyLL ( maillon ∗ source )

{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ reverseLL ( maillon ∗ l )

{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

maillon ∗ insereDebutLL ( maillon ∗ l , i n t n )

{
maillon ∗ first = creeMaillon ( n ) ;
first−>next = l ;
return first ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

132
maillon ∗ initLL ( i n t n )
{
maillon ∗ l = NULL ;
int i ;
f o r ( i = n − 1 ; i >= 0 ; i−−)
l = insereDebutLL ( l , i ) ;
return l ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

void freeLL ( maillon ∗ l )

{
maillon ∗ n ;
while ( l != NULL )
{
n = l−>next ;
free ( l ) ;
l = n;
}
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
return 0 ;
}

Exercice 3 ajout d’un élément à la fin

Erire le corps de la fonction suivante :
maillon ∗ insereFinLL ( maillon ∗ l , i n t n )

Vous insérerez un maillon contenant la valeur n à la fin de la liste dont le premier élément est pointé par l. Vous
retournerez un pointeur vers le premier élément de la liste.

Exercice 4 copie d’une liste chaînée

Erire le corps de la fonction suivante :
maillon ∗ copyLL ( maillon ∗ source )

Vous copierez la liste l et retournerez un pointeur vers le premier élément de la copie. Vous avez le droit d’utiliser
insereFinLL.

Exercice 5 inversion de l’ordre des éléments

Ecrivez un sous-programme qui inverse l’ordre des éléments d’une liste chaînée, et qui retourne un pointeur sur le
premier élément de la liste nouvellement formée.

2.12.4 Listes doublement chaînées

Pour les exercices suivants, vous pouvez utiliser ce fichier source :
#include<s t d i o . h>
#include<s t d l i b . h>

133
#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/
typedef struct dmaillon
{
i n t data ;
struct dmaillon ∗ previous ;
struct dmaillon ∗ next ;
} dmaillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct dLinkedList

{
struct dmaillon ∗ first ;
struct dmaillon ∗ last ;
} dLinkedList ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e l e s e l e m e n t s d ’ une l i s t e c h a i n e e .
∗/

void printDLL ( dLinkedList ∗ dl )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Libere tous l e s maillons , puis l i b e r e dl .
∗/

void freeDLL ( dLinkedList ∗ dl )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
A l l o u e l a memoire pour une d L i n k e d L i s t ,
i n i t i a l i s e l e s p o i n t e u r s a NULL
∗/

dLinkedList ∗ makeDLL ( )
{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Cree un m a i l l o n c o n t e n a n t l a v a l e u r n .
∗/

dmaillon ∗ makeDMaillon ( i n t n )
{

134
 return NULL ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Accroche l e m a i l l o n m a l a f i n de l a l i s t e c h a i n e e d l
∗/

void appendDMaillonDLL ( dLinkedList ∗ dl , dmaillon ∗ m )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Accroche l e m a i l l o n m au d e b u t de l a l i s t e c h a i n e e d l
∗/

void pushDMaillonDLL ( dLinkedList ∗ dl , dmaillon ∗ m )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
A j o u t e a l a f i n de d l un m a i l l o n c o n t e n a n t l a v a l e u r n .
∗/

void appendIntDLL ( dLinkedList ∗ dl , i n t n )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
A j o u t e au d e b u t de d l un m a i l l o n c o n t e n a n t l a v a l e u r n .
∗/

void pushIntDLL ( dLinkedList ∗ dl , i n t n )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
P l a c e dans l a l i s t e d o u b l e m e n t c h a i n e e
l e s v a l e u r s {0 , . . . , n}
∗/

void initDLL ( dLinkedList ∗ dl , i n t n )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
I n v e r s e l ’ o r d r e d e s e l e m e n t s de d l .

135
 ∗/

void reverseDLL ( dLinkedList ∗ dl )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Retourne une c o p i e de s o u r c e .
∗/

dLinkedList ∗ copyDLL ( dLinkedList ∗ source )

{
return NULL ;
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

/∗
Concatene f i n a l a s u i t e de d e b u t , v i d e l a l i s t e f i n .
∗/

void concatDLL ( dLinkedList ∗ debut , dLinkedList ∗ fin )

{
}

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

i n t main ( )
{
return 0 ;
}

Nous définissons comme suit une liste doublement chaînée

#include<s t d i o . h>
#include<s t d l i b . h>
#include<m a l l o c . h>

#define N 10

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct dmaillon

{
i n t data ;
struct dmaillon ∗ previous ;
struct dmaillon ∗ next ;
} dmaillon ;

/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗/

typedef struct dLinkedList

{
struct dmaillon ∗ first ;
struct dmaillon ∗ last ;
} dLinkedList ;

Implémentez les fonctions suivantes :

136
 1. void printDLL(dLinkedList∗ dl) affiche les éléments d’une liste chaînée.
2. void freeDLL(dLinkedList∗ dl) libère tous les maillons, puis libère dl.
3. dLinkedList∗ makeDLL() alloue la mémoire pour une dLinkedList, initialise les pointeurs à NULL
4. dmaillon∗ makeDMaillon(int n) crée un maillon contenant la valeur n.
5. void appendDMaillonDLL(dLinkedList∗ dl, dmaillon∗ m) accroche le maillon m à la fin de la liste chaînée dl
6. void pushDMaillonDLL(dLinkedList∗ dl, dmaillon∗ m) accroche le maillon m au début de la liste chaînée dl
7. void appendIntDLL(dLinkedList∗ dl, int n) ajoute à la fin de dl un maillon contenant la valeur n.
8. void pushIntDLL(dLinkedList∗ dl, int n) ajoute au début de dl un maillon contenant la valeur n.
9. void initDLL(dLinkedList∗ dl, int n) place dans la liste doublement chaînée les valeurs {0, ..., n − 1}
10. void reverseDLL(dLinkedList∗ dl) inverse l’ordre des éléments de dl.
11. dLinkedList∗ copyDLL(dLinkedList∗ source) retourne une copie de source.
12. void concatDLL(dLinkedList∗ debut, dLinkedList∗ fin) concatène fin à la suite de debut, vide la liste fin .

2.12.5 Fonctions récursives et listes chaînées

Complétez le code sources suivant. Les boucles sont interdites !
#include<s t d i o . h>

/∗
Dans t o u t e s l e s f o n c t i o n s à p a r t i r d ’ i n s e r e , i l e s t i n t e r d i t de
creer des maillons , t o u t e s ces operations doivent se f a i r e
par m o d i f i c a t i o n du c h a i n a g e e t non par r e c o p i e .
∗/

typedef struct lls

{
i n t data ;
struct lls ∗ next ;
} ll ;

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A l l o u e dynamiquement e t i n i t i a l i s e un m a i l l o n a v e c l e s
v a l e u r s d a t a e t ne xt , r e t o u r n e son a d r e s s e .
∗/

ll ∗ creer ( i n t data , ll ∗ next )

{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Affiche l e maillon l
∗/

void affiche ( ll ∗ l )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗

137
 A f f i c h e , dans l ’ ordre , t o u s l e s m a i l l o n s de l a l i s t e l.
∗/

void afficheTout ( ll ∗ l )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
A f f i c h e en p a r t a n t de l a f i n t o u s l e s m a i l l o n s
de l a l i s t e l .
∗/

void afficheALEnvers ( ll ∗ l )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
D e t r u i t t o u s l e s m a i l l o n s de l a l i s t e ∗ l , met ce p o i n t e u r
a NULL.
∗/

void detruit ( ll ∗∗ l )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l a l i s t e n −> n−1 −> . . . −> 2 −> 1
∗/

ll ∗ entiersALEnvers ( i n t n )
{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l a l i s t e 1 −> 2 −> . . . −> n
∗/

ll ∗ entiers ( i n t n )
{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
I n s e r e l e m a i l l o n x dans l a l i s t e l , s u p p o s e e t r i e e .
∗/

ll ∗ insere ( ll ∗ l , ll ∗ x )
{

138
 return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Tri l a l i s t e l a v e c l a methode du t r i par i n s e r t i o n , r e t o u r n e
l ’ a d r e s s e du p r e m i e r e l e m e n t de l a l i s t e t r i e e .
∗/

ll ∗ triInsertion ( ll ∗ l )
{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
R e p a r t i t l e s e l e m e n t s de l e n t r e l e s l i s t e s l 1 e t l 2 .
ex : l = 1 −> 2 −> 3 −> 4 −> 5 nous donne
l 1 = 5 −> 3 −> 1 e t l 2 = 4 −> 2
∗/

void split ( ll ∗ l , ll ∗∗ l1 , ll ∗∗ l2 )
{
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Retourne l ’ i n t e r c l a s s e m e n t d e s l i s t e s l 1 e t l 2 , s u p p o s e e s t r i e e s .
∗/

ll ∗ interclasse ( ll ∗ l1 , ll ∗ l2 )
{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
T r i e l a v e c l a methode du t r i f u s i o n , r e t o r u n e l ’ a d r e s s e
du p r e m i e r e l e m e n t de l a l i s t e t r i e e .
∗/

ll ∗ triFusion ( ll ∗ l )
{
return NULL ;
}

/∗ ∗∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗∗ ∗ ∗ ∗ ∗/

/∗
Pour t e s t e r l e s f o n c t i o n s . . .
∗/

i n t main ( )
{
return 0 ;

139
}

140