Langage c

Initiation au Langage C

Alexandre Mesl´
e

16 juin 2009

Table des mati`res
e

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

1

1.7.3 Dćlaration . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.7.4 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.7.5 Acc`s aux ´l´ments . . . . . . . . . .
e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.7.6 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.7.7 Saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.7.8 Probl`mes li´s ` la saisie bufferisé .
e e a e . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.7.9 La biblioth`que string.h . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.7.10 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.8 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.8.1 Les proc´dures . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.8.2 Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.8.3 Passage de param`tres . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.8.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.8.5 Passages de param`tre par r´f´rence
e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.9 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.9.1 D´finition . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.9.2 Dćlaration . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.9.3 Acc`s aux champs . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 45
1.9.4 Typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
1.9.5 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
1.9.6 Structures et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
1.10 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.10.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
1.10.3 Allocation dynamique de la m´moire e . . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.10.4 Passage de param`tres par r´f´rence
e ee . . . . . . . . . . . . . . . . . . . . . . . . . . 58
1.10.5 Pointeurs sur fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.11 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
1.11.1 D´finitions . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 61
1.11.2 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
1.11.3 Lecture et ćriture . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.12 Listes Chaˆ ees . . . . . . . . . . . . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.12.1 Le probl`me . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.12.2 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.12.3 Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
1.12.4 Le chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
1.12.5 Utilisation de malloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.12.6 Op´rations . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . 74
1.12.7 Listes doublement chaˆ ees . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . . . . . 74

2 Exercices 76
2.1 Variables et op´rateurs . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.1.1 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.1.2 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.1.3 Caract`res . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
2.1.4 Op´rations sur les bits (difficiles)
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
2.1.5 Morceaux choisis (difficiles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.2 Traitements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.2.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.2.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.2.3 L’ćhiquier . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.2.4 Heures et dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.2.5 Intervalles et rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
2.2.6 Pr´processeur . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
2.2.7 Nombres et lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

2

2.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
2.3.1 Compr´hension . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 84
2.3.2 Utilisation de toutes les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.3.3 Choix de la boucle la plus approprié e . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.3.4 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.3.5 Extension de la calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
2.4.1 Exercices de compr´hension . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 88
2.4.2 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
2.4.3 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.4.4 Recherche s´quentielle . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.5 Chaˆ ınes de caract`res . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.5.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.5.2 Les fonctions de string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.6.1 Góm´trie . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.6.2 Arithm´tique . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.6.3 Passage de tableaux en param`tre . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.6.4 Dćomposition en facteurs premiers .
e . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.6.5 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
2.6.6 Chaˆ ınes de caract`res . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.6.7 Programmation d’un Pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.6.8 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.7 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
2.7.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
2.7.2 Heures de la journé . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 101
2.7.3 R´pertoire t´l´phonique . . . . . . . .
e ee . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.8.1 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.8.2 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.8.3 Exercices sans sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
2.8.4 Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
2.8.5 Pointeurs et pointeurs de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
2.8.6 Passages de param`tres par r´f´rence .
e ee . . . . . . . . . . . . . . . . . . . . . . . . . 106
2.8.7 Les pointeurs sans ´toile . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 107
2.8.8 Tableau de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.8.9 Triangle de Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.8.10 Pointeurs et rćursivit´ . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.8.11 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.9.1 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.9.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.9.3 Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.9.4 Lecture et ćriture . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.9.5 Enigma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2.10 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
2.11 Listes Chaˆ ees . . . . . . . . . . . . . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.11.1 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.11.2 Maniement du chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.11.3 Op´rations sur les listes chaˆ ees . . .
e ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 120
2.11.4 Listes doublement chaˆ ees . . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 120
2.11.5 Fonctions rćursives et listes chaˆ ees
e ın´ . . . . . . . . . . . . . . . . . . . . . . . . . 121

3

A Quelques corrig´s e 124
A.1 Variables et op´rateurs . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 124
A.1.1 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
A.1.2 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
A.1.3 Caract`res . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 126
A.1.4 Op´rations binaires . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 127
A.1.5 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
A.2 Traitements conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.2.1 Prise en Main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.2.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
A.2.3 Heures et dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
A.2.4 Echiquier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
A.2.5 Intervalles et rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
A.2.6 Nombres et lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
A.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
A.3.1 Utilisation de toutes les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
A.3.2 Choix de la boucle la plus approprié . . .
e . . . . . . . . . . . . . . . . . . . . . . 142
A.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
A.4.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
A.4.2 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
A.4.3 Recherche s´quentielle . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 147
A.5 Chaˆ ınes de caract`res . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 151
A.5.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
A.5.2 Les fonctions de string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
A.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
A.6.1 Góm´trie . . . . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . . . 154
A.6.2 Arithm´tique . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 156
A.6.3 Passage de tableaux en param`tre . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 158
A.6.4 Dćomposition en facteurs premiers . . . .
e . . . . . . . . . . . . . . . . . . . . . . 159
A.6.5 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
A.6.6 Chaines de caract`res . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 161
A.6.7 Programmation d’un pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
A.6.8 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
A.7 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
A.7.1 Heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
A.7.2 R´pertoire t´l´phonique . . . . . . . . . . .
e ee . . . . . . . . . . . . . . . . . . . . . . 166
A.8 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
A.8.1 Exercices sans sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
A.8.2 Pointeurs sans ´toiles et triangle de Pascal .
e . . . . . . . . . . . . . . . . . . . . . . 171
A.8.3 Fonctions rćursives . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 173
A.8.4 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
A.9 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.9.1 Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.9.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.9.3 Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.9.4 Lecture et ćriture . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . 182
A.10 Listes Chaˆ ees . . . . . . . . . . . . . . . . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . 184
A.10.1 Pointeurs et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
A.10.2 Maniement du chaˆ ınage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
A.10.3 Listes doublement chaˆ ees . . . . . . . . .
ın´ . . . . . . . . . . . . . . . . . . . . . . 187
A.10.4 Fonctions rćursives et listes chaˆ ees . . .
e ın´ . . . . . . . . . . . . . . . . . . . . . . 190

4

B Projets 194
B.1 Agenda (pour les PPAs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

A M´thodologie
e 195
A.1 Le probl`me . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.2 Les r`gles d’or . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.2.1 Gń´ralit´s . . . . . . . . . .
e e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.2.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.2.3 Compilation s´paré . . . . .
e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
A.3 D´bogage . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
A.4 Duré de vie du code . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
A.4.1 Le code doit ˆtre rútilisable
e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
A.4.2 Le code doit ˆtre adaptable .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
A.5 Exemple : le carnet de contacts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
A.5.1 util.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
A.5.2 util.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
A.5.3 tableau.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
A.5.4 tableau.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
A.5.5 eMails.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
A.5.6 makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

5

Chapitre 1

Notes de cours

1.1 Introduction
1.1.1 D´finitions et terminologie
e
Un programme exćutable est une suite d’instructions exćuté par le processeur. Ces instructions sont
e e e
tr`s difficile ` comprendre, si par exemple, vous ouvrez avec un ´diteur de texte (notepad, emacs, etc) un
e a e
fichier exćutable, vous verrez s’afficher un charabia incompr´hensible :
e e

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ér des programmes en ćrivant des suites de chiffres et de lettres. Nous
e e
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
a e

6

(ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont ćrites s’appellent
e
du code ou encore le code source. Un compilateur est un logiciel qui lit le code source et le convertit
en un code exćutable, c’est-`-dire un ensemble d’instructions compr´hensible par le processeur. La
e a e
compilation d’une source se fait en deux ´tapes : la compilation proprement dite et le linkage. On utilise
e
en gń´ral le terme compilation en englobant les deux ´tapes prć´demment cités.
e e e e e e
– La compilation ` proprement parler produit un fichier objet, dont l’extension est .obj.
a
– Les sources peuvent ˆtre r´parties dans plusieurs fichiers, ceux-ci doivent tous ˆtre compil´s s´par´ment.
e e e e e e
Ensuite, le linkage des diff´rents fichiers objets est assemblage produisant un exćutable .exe.
e e
Certains environnement de d´veloppement servent d’´diteur, et prennent en charge la compilation et le
e e
linkage (eclipse, dev-C++).

1.1.2 Hello World !
Allez sur http://www.01net.com/telecharger/windows/Programmation/langage/fiches/2327.html,
cliquez sur t´lćharger. Installez Dev-C++. Ouvrez un nouveau fichier source. Copiez-collez le code ci-
ee
dessous dans l’´diteur :
e
#include<s t d i o . h>
#include<c o n i o . h>

int main ( )
{
p r i n t f ( ” H e l l o World ! n” ) ;
getch ( ) ;
return 0 ;
}
Sauvegardez ce fichier sous le nom helloWorld.c. Dans le menu Exćuter, cliquez sur Compiler. Remar-
e
quez que la compilation a produit un fichier helloWorld.exe. Vous avez deux fa¸ons de l’exćuter :
c e
– double-cliquez directement sur helloWorld.exe
– Dans le menu Exćuter, cliquez sur exćuter.
e e

1.1.3 Structure d’un programme C
Importation des biblioth`ques
e

#include<c o n i o . h>
Selon ce que l’on souhaite faire dans notre programme, on peut avoir besoin de diff´rentes fonctions.
e
Celles-ci sont disponibles dans des biblioth`ques. Par exemple :
e
– stdio.h propose des fonctions de saisie et d’affichage
– conio.h propose d’autre fonctions d’entrés-sorties
e

Corps du programme

int main ( )
{
p r i n t f ( ” H e l l o world ! ” ) ;
getch ( ) ;
return 0 ;
}
On place dans les accolades du main les instructions que l’on souhaite voir s’exćuter :
e
int main ( )
{

7

return 0 ;
}
Remarquez que chaque ligne se termine par un points-virgule. Pour afficher une variable de type apha-
num´rique en C, on utilise printf(<valeur ` afficher>) ;. Les litt´raux de type alphanum´riques en
e a e e
C s’ćrivent entre doubles quotes. getch() ; nous sert ` suspendre l’exćution du programme jusqu’` ce
e a e a
que l’utilisateur appuie sur une touche.
1.1.4 Commentaires
Un commentaire est une s´quence de caract`res ignoré par le compilateur, on s’en sert pour expliquer
e e e
des portions de code. Alors ayez une pensé pour les pauvres programmeurs qui vont reprendre votre
e
code apr`s vous, le pauvre correcteur qui va essayer de comprendre votre pensé profonde, ou bien plus
e e
simplement ` vous-mˆme au bout de six mois, quand vous aurez compl`tement oubli´ ce que vous aviez
a e e e
dans la tˆte en codant. On d´limite un commentaire par /* et */. Par exemple,
e e
int 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 .
e
∗/
p r i n t f ( ” H e l l o world ! n” ) ;
return 0 ;
}

8

1.2 Variables
Une variable est un emplacement de la m´moire dans lequel est stocké une valeur. Chaque variable porte
e e
une nom et c’est ce nom qui sert ` identifi´ l’emplacement de la m´moire repr´sent´ par cette variable.
a e e e e
Pour utiliser une variable, la premi`re ´tape est la dćlaration.
e e e

1.2.1 Dćlaration
e
Dćlarer une variable, c’est pr´venir le compilateur qu’un nom va ˆtre utilis´ pour d´signer un emplace-
e e e e e
ment de la m´moire. En C, on dćlare les variables juste apr`s l’accolade suivant main() (pour le moment).
e e e
On place les instructions ` exćuter ` la suite de la dćlaration de variables.
a e a e
main ( )
{
<d e c l a r a t i o n de v a r i a b l e s >

}
Nous ne travaillerons pour le moment que sur les variables de type num´rique entier. Le type qui y
e
correspond, en C, est int. On dćlare les variables enti`res de la mani`re suivante :
e e e
int <v a r 1 >, <v a r 2 >, . . . , <var n >;
Cette instruction dćlare les variables var 1, var 2, ..., var n de type entier. Par exemple,
e

int main ( )
{
int v a r i a b l e 1 , v a r i a b l e 2 ;
int a u t r e v a r i a b l e 1 , a u t r e v a r i a b l e 2 ;
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,
a e
int main ( )
{
int v ;
v = 5;
return 0 ;
}
Ce programme dćlare une variable de type entier que l’on appelle v, puis lui affecte la valeur 5. Comme
e
vous venez de le voir, il est possible d’ćrire directement dans le code une valeur que l’on donne ` une
e a
variable. Notez l’abscence de include, ce programme n’effectue aucune entré-sortie, il n’est donc pas
e
nćessaire d’importer les biblioth`ques d’entrés/sorties.
e e e

Les op´rations arihm´tiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*),
e e
la division enti`re dans l’ensemble des entiers relatifs (quotient : /, reste : %).
e
int main ( )
{
int v , w, z ;
v = 5;
w = v + 1;

9

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ćup´rer e e
la saisie d’un utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante :
s c a n f ( ”%d” , &<v a r i a b l e >);
scanf suspend l’exćution du programme jusqu’` ce que l’utilisateur ait saisi une valeur et press´ la
e a e
touche return. La valeur saisie est alors affeté ` la variable <variable>. N’oubliez surtout pas le &,
e a
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.
p r i n t f ( ”%d” , <v a r i a b l e >);
Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner
par l’apparente complexit´ de cette instruction !). Nous avons ´tendu, en algorithmique, l’instruction
e e
Afficher en intercalant des valeurs de variables entre les messages affich´s. Il est possible de faire de
e
mˆme en C :
e
p r i n t f ( ” l a v a l e u r de l a v a r i a b l e v e s t %d” , v ) ;
Cette instruction substitue ` %d la valeur de la variable v. Il est possible de l’´tendre ` volont´ :
a e a e
p r i n t f ( ” l e s v a l e u r s d e s v a r i a b l e s x , y e t z s o n t %d , %d e t %d” , x , y , z ) ;
Cette instruction substitue ` chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme
a
suivant

int main ( )
{
int a , b , c ;
a = 1;
b = 2;
c = 3
p r i n t f ( ”La v a l e u r de a e s t %d , c e l l e de b e s t %d , e t c e l l e de ”
” c e s t %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 :
a e
nom taille (t) nombre de valeurs (28t ) chaˆ de format
ıne
short 1 octet 28 valeurs %hd
int 2 octets 216 valeurs %d
long 4 octets 232 valeurs %ld

10

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

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

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

{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
e e e
sur l’intervalle :

{0000 0000, 0000 0001, 0000 0010, 0000 0011, . . . , 0111 1100, 0111 1101, 0111 1110, 0111 1111}

Et les nombres n´gatifs sur l’intervalle
e

{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ć´dent code les
e e e e
valeurs :

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

1.2.6 Flottants
Les flottants servent ` repr´senter les réls. Leur nom vient du fait qu’on les repr´sente de fa¸on scien-
a e e e c
tifique : un nombre dćimal (` virgule) muni d’un exposant (un dćalage de la virgule). Trois types de
e a e
base servent ` repr´senter les flottants :
a e
nom taille chaˆ de format
ıne
float 4 octet %f
double 8 octets %f
long double 10 octets %Lf
Il est conventionel d’ćrire des litt´raux flottants avec un point, par exemple l’approximation ` 10−2 pr`s
e e a e
de π s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le dćimal 1 000
e
s’ćrit 1e3, ` savoir 1.103 .Nous nous limiterons ` la description du type float, les autres types obíssent
e a a e
a
` des r`gles similaires.
e

11

Repr´sentation en m´moire d’un float
e e
Le codage d’un nombre de type float (32 bits) est dćoup´ en trois parties :
e e
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
a e a
m
sont cod´s en binaire, la valeur absolue d’un flottant de mantisse m et d’exposant e est 23 .2e . Le plus
e
2
(223 − 1)
grand entier qu’il est possible de coder sur 23 octets est , le plus grand exposant est 27 , donc
223
(223 − 1) (27 ) (223 − 1) (27 )
le plus grand flottant est 23
.2 , donc le plus petit est − .2 .
2 223

1.2.7 Caract`res
e
Un char sert ` repr´senter le code ASCII d’un caract`re, il est donc cod´ sur 1 octet. Il est possible
a e e e
d’affecter ` une telle variable toute valeur du code ASCII entouré de simples quotes. Par exemple,
a e
l’affectation suivante place dans a le code ASCII du caract`re ’B’.
e
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
e c
tout un nombre cod´ sur 1 octet. Pour afficher le caract`re corrspondant au code ASCII stock´ dans un
e e e
char, on utilise la chaˆ de format %c, et pour afficher le code ASCII lui-mˆme on utilise la chaˆ de
ıne e ıne
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.
e
Par cons´quent, les caract`res de code ASCII 255 et 128 correspondent aux unsigned char de valeurs
e e
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és, on les d´finit dans l’entˆte de la source, juste en dessous des #include.
e e e
La syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 d´finit une e
constante N qui a la valeur 25. Au d´but de la compilation, un programme appel´ pr´processeur
e e e
effectue un rechercher/remplacer et substitue ` toutes les occurences de <NOM CONSTANTE> la valeur
a
<valeurConstante>. Faites donc tr`s attention au fait que dans l’exemple pr´sent, le pr´processeur
e e e
va remplacer tous les N par des 25. Donc si une variable s’appelle N , le pr´processeur va le remplacer
e
par un 25 ! Si par exemple vous ćrivez
e

#define N 25

int main ( )
{
int N;
N = 12;
p r i n t f ( ”N = %d” , N ) ;
return 0 ;
}
Le pr´processeur va le transformer en
e

12

#define N 25

int main ( )
{
int 2 5 ;
25 = 1 2 ;
p r i n t f ( ”N = %d” , 2 5 ) ;
return 0 ;
}
Vous remarquez que les seules exceptions sont les valeurs d´limit´es par des ".
e e

13

1.3 Op´rateurs
e
1.3.1 Gń´ralit´s
e e e
Op´randes et arit´
e e
Lorsque vous effectuez une op´ration, par exemple 3 + 4, le + est un op´rateur, 3 et 4 sont des op´randes.
e e e
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
e a e e e
op´rateur d’arit´ 1, dit aussi unaire, s’applique ` un seul op´rande, par exemple -x, le x est l’op´rande
e e a e e
et le - unaire est l’op´rateur qui, appliqu´ ` x, nous donne l’oppos´ de celui-ci, c’est-`-dire le nombre
e e a e a
qu’il faut additionner ` x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliqu´ ` x et
a ea
y, additionne ` x l’oppos´ de y.
a e
En C, les op´rateurs sont unaires ou binaires, et il existe un seul op´rateur ternaire.
e e

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

Formes pr´fixes, postfixes, infixes
e
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
e e e e e
binaire est infixe s’il se place entre ses deux op´randes (a + b), pr´fixe s’il se place avant (+ a b),
e e
postfixe s’il se place apr`s (a b +). Vous rencontrez en C des op´rateurs unaires pr´fixes et d’autres
e e e
postfixes (on imagine difficilement un op´rateur unaire infixe), par contre tous les op´rateurs binaires
e e
seront infixe.

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

1.3.2 Les op´rateurs unaires
e
N´gation arithm´tique
e e
La n´gation arithm´tique est l’op´rateur - qui ` une op´rande x, associe l’oppos´ de x, c’est-`-dire le
e e e a e e a
nombre qu’il faut additionner ` x pour obtenir 0.
a

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

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

14

1.3.3 Les op´rateurs binaires
e
Op´rations de dćalages de bits
e e
L’op´ration a >> 1 effectue un dćalage des bits de la repr´sentation binaire de a vers la droite. Tous les
e e e
bits sont dćal´s d’un cran vers la droite, le dernier bit disparaˆ le premier prend la valeur 0. L’op´ration
e e ıt, e
a << 1 effectue un dćalage des bits de la repr´sentation binaire de a vers la gauche. Tous les bits sont
e e
dćal´s d’un cran vers la gauche, le premier bit disparaˆ et le dernier devient 0. Par exemple, 32 << 2
e e ıt
associe ` 0010 0000 << 2 la valeur dont la repr´sentation binaire 1000 0000 et 32 >> 3 associe ` 0010
a e a
0000 >> 3 la valeur dont la repr´sentation binaire 0000 0100.
e

Op´rations logiques sur la repr´sentation binaire
e e
L’op´rateur & associe ` deux op´randes le ET logique de leurs repr´sentations binaires par exemple
e a e e
60 & 15 donne 12, autrement formul´ 0011 1100 ET 0000 1111 = 0000 1100. L’op´rateur | associe `
e e a
deux op´randes le OU logique de leurs repr´sentations binaires par exemple 60 | 15 donne 63, autrement
e e
formul´ 0011 1100 OU 0000 1111 = 0011 1111. L’op´rateur ^ associe ` deux op´randes le OU exclusif
e e a e
logique de leurs repr´sentations binaires par exemple 60 ^ 15 donne 51, autrement formul´ 0011 1100
e e
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 e a e e
Lvalue par le compilateur), qui doit ˆtre une variable, une valeur calculé ` l’aide d’une expression, qui
e e a
est l’op´rande de droite. Attention, il est possible d’effectuer une affectation pendant l’´valuation d’une
e e
expression. Par exemple,
a = b + (c = 3);
Cette expression affecte ` c la valeur 3, puis affecte ` a la valeur b + c.
a a

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

15

noms op´rateurs
e
produit *, /, %
somme +, -
dćalage binaire
e >>, <<
ET binaire &
OU binaire |
affectation =
Quand deux op´rateurs sont de mˆme priorit´ le parenth`sage implicite est fait le plus ` gauche pos-
e e e e a
sible, on dit que ces op´rateurs sont associatifs ` gauche. Par exemple, le parenth`sage implicite de
e a e
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
e e
associatifs ! La seule exception est le =, qui est associatif ` droite. Par exemple,
a
a = b = c;
se dćompose en b = c suivi de a = b.
e

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

Unaires
Il est possible d’incr´menter (augmenter de 1) la valeur d’une variable i en ćrivant i++, ou bien ++i.
e e
De la mˆme fa¸on on peut dćr´menter (diminuer de 1) i en ćrivant i-- (forme postfixe), ou bien --i
e c e e e
(forme pr´fixe). Vous pouvez dćider d’incr´menter (ou de dćr´menter) la valeur d’une variable pendant
e e e e e
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
e e a e
´valué ` 1, puis est incr´menté, donc lorsque la deuxi`me op´rande a est ´valué, sa valeur est 2. Donc
e e a e e e e e e
la valeur de b apr`s l’incr´mentation est 3. L’incr´mentation contracté sous forme postfixe s’appelle une
e e e e
post-incr´mentation. Si l’on ćrit,
e e
a = 1;
b = (++a ) + a ;
On op`re une pr´-incr´mentation, ++a donne lieu ` une incr´mentation avant l’´valuation de a, donc
e e e a e e
la valeur 4 est affecté ` b. On peut de fa¸on analogue effectuer une pr´-decr´mentation ou a post-
e a c e e
decr´mentation. Soyez tr`s attentifs au fait que ce code n’est pas portable, il existe des compilateurs
e e
qui ´valuent les op´randes dans le d´sordre ou diff`rent les incr´mentations, donnant ainsi des r´sultats
e e e e e e
autres que les r´sultats thóriques expos´s prć´dement. Vous n’utiliserez donc les incr´mentation et
e e e e e e
decr´mentation contractés que lorsque vous serez certain que l’ordre d’´valuation des op´randes ne
e e e e
pourra pas influer sur le r´sultat.
e

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

16

avant apr`s
e
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 & 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 e e e

1.3.5 Op´rations h´t´rog`nes
e e e e
Le fonctionnement par d´faut
e
Nous ordonnons de fa¸on grossi`re les types de la fa¸on suivante : long double > double > float >
c e c
unsigned long > long > unsigned int > int > unsigned short > short > char. Dans un cal-
cul 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´
u e ee e e ee e
(conform´ment ` l’ordre ńonc´ ci-avant) est s´lectionn´ et l’autre est converti dans le type T .
e a e e e e

Le probl`me
e
Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer
1
l’inverse d’un nombre entier x, et que vous codez
x
int i = 4 ;
p r i n t f ( ”L ’ i n v e r s e de %d e s t %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
e e
entier, c’est la division enti`re est effectué, et de toute ´vidence le r´sultat est 0. Changer la chaˆ de
e e e e ıne
format
int i = 4 ;
p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1/ i ) ;
se r´v`lera aussi d’une inefficacit´ notoire : non seulement vous vous taperez un warning, mais en plus
e e e
printf lira un entier en croyant que c’est un flottant. Alors comment on se sort de l` ? Ici la bidouille
a
est simple, il suffit d’ćrire le 1 avec un point :
e
int i = 4 ;
p r i n t f ( ”L ’ i n v e r s e de %d e s t %f n” , i , 1 . / i ) ;
Le compilateur, voyant un op´rande de type flottant, convertit lors du calcul l’autre op´rande, i, en
e e
flottant. De ce fait, c’est une division flottante et non enti`re qui est effectué. Allons plus loin : comment
e e
faire pour appliquer une division flottante ` deux entiers ? Par exemple :
a
int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %f n” , i , j , i / j ) ;
Cette fois-ci c’est inextricable, vous pouvez placer des points o` vous voudrez, vous n’arriverez pas `
u a
vous d´barasser du warning et ce programme persistera ` vous dire que ce quotient est -0.000000 ! Une
e a
solution particuli`rement crade serait de recopier i et j dans des variables flottantes avant de faire la
e
division, une autre m´thode de bourrin est de calculer (i + 0.)/j. Mais j’esp`re que vous rálisez que
e e e
seuls les boeufs proc`dent de la sorte.
e

Le cast
Le seul moyen de vous sortir de l` est d’effectuer un cast, c’est ` dire une conversion de type sur com-
a a
mande. On caste en pla¸ant entre parenth`se le type dans lequel on veut convertir juste avant l’op´rande
c e e
que l’on veut convertir. Par exemple,

17

int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %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
a c
op´rande, j, est aussi convertie en float. La division est donc une division flottante. Notez bien que le
e
cast est un op´rateur unaire, donc prioritaire sur la division qui est un op´rateur binaire, c’est pour ¸a
e e c
que la conversion de i a lieu avant la division. Mais si jamais il vous vient l’idé saugrenue d’ćrire
e e
int i = 4 , j= 5 ;
p r i n t f ( ”Le q u o t i e n t de %d e t %d e s t %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,
e e
mais comme la division a lieu avant toute conversion, c’est le r´sultat d’une division enti`re qui est converti
e e
en flottant, vous avez donc le mˆme r´sultat que si vous n’aviez pas du tout cast´.
e e e

1.3.6 Les priorit´s
e
Ajoutons le cast au tableau des priorit´s de nos op´rateurs :
e e
noms op´rateurs
e
op´rateurs unaires cast, -, ~, ++, --
e
produit *, /, %
somme +, -
dćalage binaire
e >>, <<
ET binaire &
OU binaire |
affectation =

18

1.4 Traitements conditionnels
On appelle traitement conditionnel un portion de code qui n’est pas exćuté syst´matiquement, c’est `
e e e a
dire des instructions dont l’exćution est conditionné par le succ`s d’un test.
e e e

1.4.1 Si ... Alors
Principe
En algorithmique un traitement conditionnel se r´dige de la sorte :
e
si condition alors
instructions
fin

Si la condition est v´rifié, alors les instructions sont exćutés, sinon, elles ne sont pas exćutés.
e e e e e e
L’exćution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors
e
et le finSi. Un traitement conditionnel se code de la sorte :
i f (< c o n d i t i o n >)
{

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

Comparaisons
La formulation d’une condition se fait souvent ` l’aide des op´rateurs de comparaison. Les op´rateurs de
a e e
comparaison disponibles sont :
– == : ´galit´
e e
– != : non-´galit´
e e
– <, <= : inf´rieur `, respectivement strict et large
e a
– >, >= : sup´rieur `, respectivement strict et large
e a
Par exemple, la condition a == b est v´rifié si et seulement si a et b ont la mˆme valeur au moment o`
e e e u
le test est ´valu´. Par exemple,
e e

int main ( )
{
int i ;
p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ;
s c a n f ( ”%d” , &i ) ;
i f ( i == 0 )
{
p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ;
}
p r i n t f ( ” 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
u e e e e
printf("Vous avez saisi une valeur nullen.") sera bien exćuté. Si le test n’est pas v´rifi´, les
e e e e
instructions du bloc ... suivant le if sont ignorés.
e

19

Si ... Alors ... Sinon
Il existe une forme ´tendue de traitement conditionnel, on la note en algorithmique de la fa¸on suivante :
e c
si condition alors
instructions
sinon
autresinstructions
fin

Les instructions d´limités par alors et sinon sont exćutés si le test est v´rifi´, et les instructions
e e e e e e
d´limités par sinon et finSi sont exćutés si le test n’est pas v´rifi´. On traduit le traitement condi-
e e e e e e
tionnel ´tendu de la sorte :
e
i f (< c o n d i t i o n >)
{

}
else
{

}
Par exemple,

int main ( )
{
int i ;
p r i n t f ( ” S a i s i s s e z une v a l e u r : ” ) ;
s c a n f ( ”%d” , &i ) ;
i f ( i == 0 )
{
p r i n t f ( ”Vous avez s a i s i une v a l e u r n u l l e n . ” ) ;
}
else
{
p r i n t f ( ”La v a l e u r que vous s a i s i , ”
” a s a v o i r %d , n ’ e s t pas n u l l e . n” , i ) ;
}
return 0 ;
}
Notez la pr´sence de l’op´rateur de comparaison ==. N’utilisez jamais = pour comparer deux va-
e e
leurs !.

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

int main ( )
{
int i , j ;

20

p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ;
s c a n f ( ”%d %d” , &i , &j ) ;
p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ;
i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
{
p r i n t f ( ” p o s i t i f n . ” ) ;
}
else
{
printf (” n´gatif ” ) ;
e
}
p r i n t f ( ” . n” ) ;
return 0 ;
}

Accolades superflues
Lorsqu’une seule instruction d’un bloc if doit ˆtre exćuté, les accolades ne sont plus nćessaires. Il est
e e e e
possible par exemple de reformuler le programme prć´dent de la sorte :
e e

int main ( )
{
int i , j ;
p r i n t f ( ” S a i s i s s e z deux v a l e u r s : ” ) ;
s c a n f ( ”%d %d” , &i , &j ) ;
p r i n t f ( ”Le p r o d u i t de c e s deux v a l e u r s e s t ” ) ;
i f ( ( i < 0 && j < 0 ) | | ( i >= 0 && j>= 0 ) )
p r i n t f ( ” p o s i t i f n . ” ) ;
else
printf (” n´gatif ” ) ;
e
p r i n t f ( ” . n” ) ;
return 0 ;
}

Op´rateur ternaire
e
En pla¸ant l’instruction suivante ` droite d’une affectation,
c a
<v a r i a b l e > = (< c o n d i t i o n >) ? <v a l e u r > : <a u t r e v a l e u r > ;
on place valeur dans variable si condition est v´rifi´, autrevaleur sinon. Par exemple,
e e
max = ( i >j ) ? i : j ;
place la plus grande des deux valeurs i et j dans max. Plus gń´ralement on peut utiliser le si ternaire
e e
dans n’importe quel calcul, par exemple
p r i n t f ( ”%dn” , ( 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’ćrit, avec la syntaxe suivante :
e

21

switch(< nomvariable >)
{
case <v a l e u r 1 > : ; break ;
case <v a l e u r 2 > : ; break ;
/∗ . . . ∗/
case <v a l e u r n > : ; break ;
default : /∗ i n s t r u c t i o n s ∗/
}
N’oubliez surtout pas les break ! Si par exemple, nous voulons afficher le nom d’un mois en fonction de
son num´ro, on ćrit
e e
switch ( numeroMois )
{
case 1 : p r i n t f ( ” j a n v i e r ” ) ; break ;
case 2 : p r i n t f ( ” f e v r i e r ” ) ; break ;
case 3 : p r i n t f ( ” mars ” ) ; break ;
case 4 : p r i n t f ( ” a v r i l ” ) ; break ;
case 5 : p r i n t f ( ”mai” ) ; break ;
case 6 : p r i n t f ( ” j u i n ” ) ; break ;
case 7 : p r i n t f ( ” j u i l l e t ” ) ; break ;
case 8 : p r i n t f ( ” aout ” ) ; break ;
case 9 : p r i n t f ( ” septembre ” ) ; break ;
case 10 : p r i n t f ( ” o c t o b r e ” ) ; break ;
case 11 : p r i n t f ( ” novembre ” ) ; break ;
case 12 : p r i n t f ( ” decembre ” ) ; break ;
default : p r i n t f ( ” Je c o n n a i s pas c e mois . . . ” ) ;
}

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

Utilisation dans des if
Lorsqu’une condition est ´valué, par exemple lors d’un test, cette condition prend ` ce moment la valeur
e e a
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
e e e e
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én vrai. De ce fait,
e e e
le test if (8) est toujours v´rifi´. Par contre le test if (0) n’est jamais v´rifi´.
e e e e

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
e e
´valué, elle prend la valeur 1 si elle est v´rifi´, 0 dans le cas contraire. par exemple,
e e e e
x = (3 >2);
On remarque que (3>2) est une condition. Pour dćider quelle valeur doit ˆtre affecté ` x, cette condition
e e e a
est ´valué. Comme dans l’exemple ci-dessus la condition est v´rifié, alors elle prend la valeur 1, et cette
e e e e
valeur est affecté ` x.
e a

22

Connecteurs logiques binaires
Les connecteurs || et && peuvent s’appliquer ` des valeurs (ou variables) enti`res. Observons l’exemple
a e
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
a e
faux, alors leur conjonction est fausse. Donc (3 && 0) a pour valeur 0. La condition 0 || 1 est ensuite
´valué et prend la valeur vrai. Donc la valeur 1 est affecté ` x.
e e e a

Op´rateur de n´gation
e e
Parmi les connecteurs logiques se trouve !, dit op´rateur de n´gation. La n´gation d’une expression est
e e e
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é ` x.
e e a

1.4.4 Les priorit´s
e
Compl`tons notre tableau
e des priorit´s en y adjoignant les connecteurs logiques et les op´rateurs de
e e
comparaison :
noms op´rateurs
e
op´rateurs unaires
e cast, -, ~, !, ++, --
produit *, /, %
somme +, -
dćalage binaire
e >>, <<
comparaison >, <, >=, <=
´galit´
e e ==, !=
ET binaire &
OU binaire |
connecteurs logiques &&, ||
if ternaire () ? :
affectations =, +=, -=, . . .

1.4.5 Pr´processeur
e
Macro-instructions
Le C nous permet de placer ` peu pr`s n’importe quoi dans les constantes. Si par exemple, on est lass´
a e e
d’ćrire des instructions de retour ` la ligne, il suffit de d´finir
e a e
#define RC p r i n t f ( ”n” )
Dans ce cas, toutes les occurrences de RC dans le code seront remplacés par des printf("n"). Par
e
exemple

#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 ( ” M i l i e u ” )

23

Langage c

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (17)

Ähnlich wie Langage c

Ähnlich wie Langage c (20)

Langage c