langage_c

Embed Size (px)

Citation preview

  • Support de Cours de Langage C

    Christian Bac

    24 avril 2003

  • ii

    cChristian Bac 1985-2003

  • Table des matires

    Avant-propos xi

    1 Historique et prsentation 1

    1.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

    1.2 Prsentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

    1.3 Ides fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

    1.4 En-chaneur de passes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

    1.4.1 Pr-processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    1.4.2 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    1.4.3 Optimiseur de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    1.4.4 Assembleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    1.4.5 diteur de liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    1.4.6 Quelques options de cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

    2 Gnralits sur la syntaxe 9

    2.1 Mise en page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

    2.1.1 Identiant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

    2.1.2 Espaces lexicaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

    2.2 Mots rservs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

    2.3 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

    2.4 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

    3 Types et variables 11

    3.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

    3.1.1 Types entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

    3.1.2 Types avec parties dcimales . . . . . . . . . . . . . . . . . . . . . . . . . . 12

    3.1.3 Tailles des types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

    3.2 Constantes associes aux types de base . . . . . . . . . . . . . . . . . . . . . . . . . 13

    3.2.1 Constantes de type entier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

    3.2.2 Constantes avec partie dcimale . . . . . . . . . . . . . . . . . . . . . . . . 14

    3.2.3 Constantes de type caractre . . . . . . . . . . . . . . . . . . . . . . . . . . 14

    cChristian Bac 1985-2003

  • iv TABLE DES MATIRES

    3.2.4 Chanes de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

    3.3 Qualicatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

    3.4 Taille et normalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

    3.5 Dnition de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

    3.6 Types drivs des types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

    3.6.1 Tableaux et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

    3.6.2 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

    3.7 Initialisation de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

    3.8 Conversion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

    3.8.1 Conversions implicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

    3.9 Dclaration et dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    3.10 Exercices sur les types et variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    3.10.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    3.10.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    3.10.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

    3.10.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

    4 Elments de base 27

    4.1 Bonjour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

    4.2 Lire et crire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

    4.3 Quelques oprations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

    4.4 Plus sur printf() et scanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

    4.5 Exercices sur printf() et scanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    4.5.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    4.5.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    4.5.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    4.5.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

    5 Oprateurs et expressions 37

    5.1 Oprateurs un-aires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

    5.1.1 Oprateur de rfrencement . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

    5.1.2 Oprateur de drfrencement ou indirection . . . . . . . . . . . . . . . . . 38

    5.1.3 Utilisation des & et * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

    5.1.4 Oprateurs d'incrmentation et de dcrmentation . . . . . . . . . . . . . . 39

    5.1.5 Oprateur de taille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

    5.1.6 Oprateur de ngation logique . . . . . . . . . . . . . . . . . . . . . . . . . 40

    5.1.7 Plus et moins unaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

    5.1.8 Complment un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

    5.2 Oprateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

    5.2.1 Oprateurs arithmtiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

    cChristian Bac 1985-2003

  • TABLE DES MATIRES v

    5.2.2 Oprateurs manipulant les bits . . . . . . . . . . . . . . . . . . . . . . . . . 41

    5.2.3 Oprateurs de dcalage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

    5.2.4 Oprateurs de relation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

    5.2.5 Oprateur binaire d'aectation et de succession . . . . . . . . . . . . . . . . 44

    5.2.6 Oprateurs d'aectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

    5.2.7 Oprateur ternaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

    5.2.8 Prcdence des oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

    5.3 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

    5.4 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

    5.5 Exercices sur les oprateurs et les expressions . . . . . . . . . . . . . . . . . . . . . 48

    5.5.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

    5.5.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

    5.5.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

    5.5.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

    5.5.5 Exercice 5 : Operateur ternaire . . . . . . . . . . . . . . . . . . . . . . . . . 49

    5.5.6 Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

    6 Instructions de contrle 57

    6.1 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

    6.1.1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

    6.1.2 Table de branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

    6.2 Instructions itratives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

    6.2.1 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

    6.2.2 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

    6.2.3 do while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

    6.2.4 Remarques sur les instructions itratives . . . . . . . . . . . . . . . . . . . . 63

    6.3 Ruptures de squence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

    6.3.1 continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

    6.3.2 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

    6.3.3 goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

    6.3.4 return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

    6.4 Exercices sur les instructions de contrle . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.4.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.4.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.4.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.4.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.5 Exercices sur les ruptures de squence . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.5.1 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    6.5.2 Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

    cChristian Bac 1985-2003

  • vi TABLE DES MATIRES

    7 Programmation structure 83

    7.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

    7.2 Ides fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

    7.3 Langage C et programmation structure . . . . . . . . . . . . . . . . . . . . . . . . 84

    7.3.1 Ambitions du langage C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

    7.3.2 C et structures fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . 84

    7.4 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

    7.4.1 Exemple avec des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

    7.4.2 Exemple avec une boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

    8 Fonctions 95

    8.1 Dnition d'une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

    8.2 Retour de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

    8.3 Passage des paramtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

    8.3.1 Passage de constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

    8.3.2 Passage de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

    8.4 Utilisation de pointeurs en paramtres . . . . . . . . . . . . . . . . . . . . . . . . . 99

    8.5 Conversion de type lors des appels . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

    8.6 Rcursivit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

    8.7 Arguments de la fonction main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

    8.8 Pointeur de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

    8.9 tapes d'un appel de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

    8.10 Exercices sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

    8.10.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

    8.10.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

    8.10.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

    9 Compilations spares 111

    9.1 Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

    9.2 Fichier source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

    9.3 Visibilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

    9.3.1 Espaces de nommage et visibilit . . . . . . . . . . . . . . . . . . . . . . . . 114

    9.3.2 Extension de la visibilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

    9.4 Prototypes des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

    9.5 Fonctions externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

    9.6 Fonctions dnies ultrieurement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

    9.7 Vrication des prototypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

    9.8 Multiples dclarations et dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . 117

    9.8.1 Fichiers d'inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

    9.8.2 Rduction de la visibilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

    cChristian Bac 1985-2003

  • TABLE DES MATIRES vii

    9.8.3 Variables locales rmanentes . . . . . . . . . . . . . . . . . . . . . . . . . . 119

    9.8.4 Travailler en groupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

    9.9 Exercices sur les fonctions et la visibilit des variables . . . . . . . . . . . . . . . . 121

    9.9.1 Exercice 1 : simulation d'un ascenseur . . . . . . . . . . . . . . . . . . . . . 121

    9.9.2 Exercice 2 : racines d'une quation du deuxime degr . . . . . . . . . . . . 121

    9.9.3 Exercice 3 : utilisation des chiers d'inclusion . . . . . . . . . . . . . . . . . 121

    10 Pointeurs et tableaux 129

    10.1 Tableaux une dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

    10.2 Arithmtique d'adresse et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

    10.3 Tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

    10.4 Pointeurs et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

    10.5 Tableau de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

    10.6 Pointeurs vers un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

    10.7 Exercices sur les tableaux et les pointeurs . . . . . . . . . . . . . . . . . . . . . . . 135

    10.7.1 Exercice 1 : tri de tableaux d'entiers . . . . . . . . . . . . . . . . . . . . . . 135

    11 Structures 143

    11.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

    11.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

    11.2.1 Oprations sur les champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

    11.2.2 Oprations sur la variable dans son ensemble . . . . . . . . . . . . . . . . . 144

    11.3 Structures et listes chanes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

    11.4 Champs de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

    11.5 Exercices sur les structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

    11.5.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

    11.5.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

    12 Unions 149

    12.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

    12.2 Accs aux champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

    12.3 Exercices sur les unions et les champs de bits . . . . . . . . . . . . . . . . . . . . . 150

    12.3.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

    12.3.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

    13 numrations 153

    13.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

    13.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

    13.3 Limites des numrations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

    14 Types synonymes et complexes 157

    cChristian Bac 1985-2003

  • viii TABLE DES MATIRES

    14.1 Types synonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

    14.2 Types complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

    14.3 Fonctions et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

    14.4 Exercices sur les dclarations complexes . . . . . . . . . . . . . . . . . . . . . . . . 160

    14.4.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

    14.4.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

    14.4.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

    15 Prprocesseur 165

    15.1 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

    15.2 Inclusion de chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

    15.3 Variables de pr-compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

    15.3.1 Dnition de constantes de compilation . . . . . . . . . . . . . . . . . . . . 168

    15.3.2 Dnition destine la slection . . . . . . . . . . . . . . . . . . . . . . . . 168

    15.4 Dnition de macro-expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

    15.5 Eacement d'une dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

    15.6 Dnition l'appel de l'enchaneur de passes . . . . . . . . . . . . . . . . . . . . . 169

    15.7 Slection de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

    15.7.1 Slection avec #if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

    15.7.2 Slection avec #ifdef et #ifndef . . . . . . . . . . . . . . . . . . . . . . . . 171

    15.8 Exercices sur le prprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

    15.8.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

    15.8.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

    16 Entres-sorties de la bibliothque 179

    16.1 Entre-sorties standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

    16.1.1 changes caractre par caractre . . . . . . . . . . . . . . . . . . . . . . . . 180

    16.1.2 changes ligne par ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

    16.1.3 changes avec formats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

    16.2 Ouverture d'un chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

    16.3 Fermeture d'un chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

    16.4 Accs au contenu du chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

    16.4.1 Accs caractre par caractre . . . . . . . . . . . . . . . . . . . . . . . . . . 185

    16.4.2 Accs ligne par ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

    16.4.3 Accs enregistrement par enregistrement . . . . . . . . . . . . . . . . . . . . 188

    16.5 Entre-sorties formates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

    16.5.1 Formats : cas de la lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

    16.5.2 Formats : cas de l'criture . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

    16.5.3 Conversion sur les entre-sorties standards . . . . . . . . . . . . . . . . . . . 193

    16.5.4 Conversion en mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

    cChristian Bac 1985-2003

  • TABLE DES MATIRES ix

    16.5.5 Conversion dans les chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

    16.6 Dplacement dans le chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

    16.7 Gestion des tampons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

    16.8 Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

    17 Autres fonctions de la bibliothque 203

    17.1 Fonctions de manipulation de chanes de caractres . . . . . . . . . . . . . . . . . . 203

    17.2 Types de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

    17.3 Quelques fonctions gnrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

    17.3.1 system() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

    17.3.2 exit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

    GNU Free Documentation License 207

    17.4 Applicability and Denitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

    17.5 Verbatim Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

    17.6 Copying in Quantity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

    17.7 Modications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

    17.8 Combining Documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

    17.9 Collections of Documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

    17.10Aggregation With Independent Works . . . . . . . . . . . . . . . . . . . . . . . . . 211

    17.11Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

    17.12Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

    17.13Future Revisions of This License . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

    Liste des programmes exemples 212

    Liste des gures 215

    Liste des tableaux 218

    Bibliographie 220

    Index 221

    cChristian Bac 1985-2003

  • x TABLE DES MATIRES

    cChristian Bac 1985-2003

  • Avant-propos

    Notice de copyright

    -

    NOTICE de COPYRIGHT

    cCe support de cours correspond au cours de langage C de Christian Bac (ci-aprs l'auteur, je

    ou moi) de l'Institut National de Tlcommunications, 9 rue Charles Fourier 91011, vry, France.

    Ce document est disponible aux formats latex, PostScript ou HTML, sur le web l'URL :

    http ://picolibre.int-evry.fr/projects/coursc/.

    Il est fourni tel quel, l'auteur ayant fait de son mieux pour supprimer les erreurs, sans garantie

    sur son utilisabilit, ni sur l'exactitude des informations qu'il contient.

    Vous avez le droit de copier, distribuer et/ou modier ce document selon les termes de la

    licence de documentation libre, version 1.1 ou toute version postrieure publie par la Free Software

    Foundation ; avec une section invariante le chapitre Avant-propos qui contient cette licence, sans

    texte spcique en premire et en quatrime de couverture. Une copie de la licence est inclue dans

    le chapitre 17.3.2 intitul "GNU Free Documentation License".

    Toute remarque ou erreur peut tre notie l'auteur l'adresse lectronique suivante :

    Christian.Bac AT int-evry.fr

    Fin de la NOTICE de COPYRIGHT

    c-

    Conventions d'criture

    Voici les conventions d'criture suivies dans ce support :

    le style italique n'est quasiment jamais utilis car je ne l'aime pas, je le rserve pour les phrases

    en anglais comme The C programming Language et pour les locutions latines comme versus ;

    les caractres de type imprimante boule (teletype) sont utiliss pour les noms de chiers

    et les parties de programme, comme /usr/include/stdio.h ;

    le style gras est utilis lorsqu'un mot me semble important, par exemple instructions ;

    les caractres sont plus larges dans l'nonc de rgles ou de parties de syntaxe telles que

    la syntaxe de la conversion explicite : (type) expression ;

    les mots qui ne sont pas franais mais sont souvent utiliss dans le jargon des informaticiens

    comme quote sont considrs comme de type neutre et se voient appliquer le genre masculin.

    Ainsi je peux appeler un index-noeud du systme de chiers UNIX : un inode ;

    dans les dessins reprsentant l'espace mmoire occup par les variables ou les tableaux, les

    noms entours par des pointills sont des adresses et non des variables.

    cChristian Bac 1985-2003

  • xii

    Vocabulaire courant

    Voici quelques mots que j'utilise de manire courante :

    Bit (Binary digiT) ou lment binaire, la plus petite partie manipulable par un ordinateur. Comme

    son nom l'indique un lment binaire peut prendre deux valeurs : 0 ou 1.

    Octet ou byte, le groupe de bits qui permet de supporter la reprsentation d'un caractre. Ce

    groupe est le plus souvent (comme son nom l'indique) constitu de huit bits. En langage C,

    l'octet sert dans les calculs d'occupation d'espace mmoire et en particulier les variables plus

    compliques comme le mot machine ont une taille donne en nombre d'octets.

    Pile ou pile d'excution, c'est une partie de l'espace mmoire d'une application qui permet au

    programme de tenir jour des sries de variables actives. Cet espace est gr comme une pile

    d'assiettes, c'est--dire que l'on peut ajouter de l'espace (faire grandir la pile) ou diminuer

    cet espace seulement par le haut. Ainsi, les derniers lments qui ont t ajouts sur une

    pile sont les plus facilement accessible, une pile reprsente le modle LIFO (Last In First

    Out) les derniers lments qui y sont ajouts sont les premiers pouvoir tre retirs. Les

    oprations d'agrandissement ou de rduction de la pile sont faites de manire automatique

    lors des appels de fonctions et respectivement des retours de fonctions. La pile est gre

    partir d'un espace mmoire de taille xe qui est attribu de manire automatique par le

    systme d'exploitation. Le processeur tient jour sa relation avec la pile travers un registre

    interne qui dcrit le sommet de pile et un autre registre qui maintient un lien sur le contexte

    (arguments de l'appel et variables locales).

    Un peu d'histoire

    Ce cours de langage C a la gnalogie suivante :

    Gnse 1. Il a t cr en 1985 lorsque j'tais au centre de calcul du CNET Paris A, pour

    assurer la formation en interne.

    2. La premire version tait tape avec les accents franais grce une version d'Emacs

    sur Multics amliore par M. Arditti. Cette version d'Emacs permettait de taper les

    accents.

    3. Les exercices associs ont t raliss sur une machine de type SM90.

    4. Les personnes m'ayant aid dans la ralisation de cette premire version sont : M.

    Auguste et M. Sabatier du CNET.

    Tro 1. Lorsque le DWB (Documentation WorkBench) a t disponible suite une intense par-

    ticipation du CNET travers la personne de M. Gien, dans l'organisation de la conf-

    rence Europenne sur UNIX Paris en 1986, j'ai dcid de faire migrer ce cours sous

    une version troff.

    2. J'ai alors choisi d'utiliser les macros qui me semblaient devoir tre la future rfrence

    car elles faisaient partie de la distribution d'UNIX system V, les macros -mm (je crois

    que j'ai t le seul).

    3. Les premires gures sont apparues dans ce support grce la disponibilit de l'utilitaire

    pic.

    4. Les personnes m'ayant aid dans la ralisation de cette version sont : M. Fondain et M.

    Horn du CNET.

    Utilisation en formation continue Cette version m'a suivi lorsque j'ai quitt le CNET pour

    venir travailler l'INT en 1989. Elle a alors servi de support de cours pour la mise en place

    d'un ensemble de cours dus l'arrive du systme UNIX dans les services oprationnels, par

    le service national de la formation de France Tlcom.

    Macintosh J'ai arrt de modier cette version en 1991, pour deux raisons :

    cChristian Bac 1985-2003

  • CHAPITRE 0. AVANT-PROPOS xiii

    1. premirement, j'ai crit des addendas avec Microsoft Word pour Macintosh. Ces ad-

    dendas avaient pour but d'expliquer les modications apportes par la normalisation

    du langage.

    2. deuximement, j'ai constitu un jeu de transparents partir de ce cours en supprimant

    des phrases et en modiant les polices de caractres de manire le rendre lisible une

    fois projet. Ce jeu de transparents est devenu mon nouveau support de cours et je l'ai

    fait voluer de manire indpendante.

    LaTeX J'ai dcid en 1997 de reconstituer ce support en utilisant LaTeX, avec plusieurs buts :

    1. pour moi, ce fut un trs bon apprentissage de LaTeX et il constitue une sorte de rfrence

    lorsque je veux rdiger un nouveau document ;

    2. grce des outils comme LaTeX2HTML, je peux permettre aux autres de consulter ce

    support sur le World Wide Web ;

    3. j'ai mesur la limite des transparents surtout lorsqu'ils sont utiliss par les lves comme

    support de cours.

    Je tiens souligner la participation active de Mmes. Monget et Carpentier, Ms. Conan, Volt

    et Laleve dans la relecture et la correction de ce support. Je suis aussi redevable, ce dernier

    de moult conseils relatifs l'utilisation de LaTeX2e.

    GnuFDL En 2003, je suis convaincu des vertus du partage au travers d'Internet, non seulement

    des codes mais aussi du savoir, j'ai plac ce cours sous licence GNU Free Documentation

    Licence pour lui permettre de continuer vivre et pour faciliter son utilisation par mes

    collgues enseignants francophones. Pour l'occasion, j'en ai prott pour associer ce support

    quelques exercices et leurs corrigs qui taient sur un support spar.

    Je tiens enn remercier les internautes qui m'envoient des correctifs ou des remarques qui

    permettent ce cours de s'amliorer.

    cChristian Bac 1985-2003

  • xiv

    cChristian Bac 1985-2003

  • Chapitre 1

    Historique et prsentation

    Ce chapitre essaye de placer le langage C [BK78] dans son contexte historique et technique, de

    manire approcher l'tat d'esprit du langage qui nous permet de deviner les rgles sous-jacentes

    au langage sans pour cela avoir les mmoriser.

    1.1 Historique

    Le langage C [DR78] est li la conception du systme UNIX

    1

    par les Bell-Labs. Les langages

    ayant inuenc son dveloppement sont :

    le langage BCPL de M. Richards 1967 ;

    le langage B dvelopp aux Bell-Labs 1970.

    Ces deux langages partagent avec le langage C :

    les structures de contrle ;

    l'usage des pointeurs ;

    la rcursivit.

    Ces deux langages prdcesseurs du C avaient la particularit d'tre sans type. Ils ne tra-

    vaillaient que sur des donnes dcrites par un mot machine ce qui leur donnait un degr de

    portabilit nul. Le langage C comble ces lacunes en introduisant des types de donnes tels que

    l'entier, ou le caractre.

    Les dates marquantes de l'histoire du langage C sont les suivantes :

    1970 diusion de la famille PDP 11.

    1971 dbut du travail sur le langage C, car le PDP 11 peut manipuler un octet alors que

    son mot mmoire est de 2 octets, il est ncessaire pour utiliser les fonctionnalits du PDP11

    introduire un type de donne char et un type int. Ces notions de type n'tant pas prises en

    compte par le langage B, elles le seront dans son successeur le C.

    1972 la premire version de C est crite en assembleur par Brian W. Kernighan et Dennis

    M. Ritchie.

    1973 Alan Snyder crit un compilateur C portable (thse MIT).

    1975 Steve C. Johnson crit et prsente le PCC (Portable C Compiler). C'tait l'poque

    le compilateur le plus rpandu. Le PCC a longtemps assur sa propre norme puisqu'il tait

    plus simple de porter le PCC que de rcrire un compilateur C (25 % du code du PCC

    modier).

    1987 dbut de la normalisation du langage par l'IEEE avec constitution d'un comit appel :

    X3 J-11.

    1

    l'poque UNIX tait une marque dpose des laboratoires Bell. Aujourd'hui, c'est devenu un nom quasiment

    commun :-), bien que la marque soit toujours la proprit de The Open Group qui pratique des programmes de

    certication.

    cChristian Bac 1985-2003

  • 2 1.2. PRSENTATION DU LANGAGE

    1989 sortie du premier document normalis appel norme ANSI X3-159.

    1990 ralisation du document nal normalis auprs de l'ISO : ISO/IEC 9899 [ISO89] ;

    1999 premire rvision de la norme ISO/IEC 9899 [ISO99].

    Jusqu'en 1987, il n'y avait pas de norme. Le livre "The C Programming Language" [BK78] de

    B. W. Kernighan et D. M. Ritchie dnit le langage. Ce livre contient une description prcise du

    langage appele "C Reference Manual". Ce livre qui a lui aussi t remis au gout du jour en 1988

    [BK88] ainsi que la norme ISO [ISO89] sont la base de ce cours.

    Le livre de Philippe Dax [Dax92] est lui aussi une bonne introduction pour l'apprentissage de

    ce langage.

    1.2 Prsentation du langage

    Le langage C est un langage de bas niveau dans le sens o il permet l'accs des donnes que

    manipulent les ordinateurs (bits, octets, adresses) et qui ne sont pas souvent disponibles partir

    de langages volus tels que Fortran, Pascal ou ADA.

    Le langage C a t conu pour l'criture de systmes d'exploitation et du logiciel de base. Plus

    de 90% du noyau du systme UNIX est crit en langage C. Le compilateur C lui-mme est crit en

    grande partie en langage C ou partir d'outils gnrant du langage C [SJ78]. Il en est de mme

    pour les autres outils de la chane de compilation (assembleur, diteur de liens, pr-processeur).

    De plus, tous les utilitaires du systme sont crits en C (shell, outils).

    Il est cependant susamment gnral pour permettre de dvelopper des applications varies

    de type scientique ou encore pour l'accs aux bases de donnes. Par le biais des bases de donnes,

    il est utilis dans les applications de gestion. De nombreux logiciels du domaine des ordinateurs

    personnels, tels que Microsoft Word ou Microsoft Excel, sont eux-aussi crits partir de langage

    C ou de son successeur orient objet : C++ [Str86].

    Bien que pouvant tre considr de bas niveau, le langage C supporte les structures de base

    ncessaires la conception des applications structures. Cette caractristique le range dans la

    catgorie des langages de haut niveau. Il est aussi un des premiers langages orant des possibilits

    de programmation modulaire, c'est--dire qu'un programme de langage C peut tre constitu

    de plusieurs modules. Chaque module est un chier source que l'on peut compiler de manire

    autonome pour obtenir un chier objet. L'ensemble des chiers objets participants un programme

    doivent tre associs pour constituer un chier excutable.

    Lorsque nous parlons du langage C, dans cette premire partie, nous faisons rfrence ce que

    sait faire le compilateur lui-mme. Comme nous le verrons plus loin dans la section 1.4, plusieurs

    outils interviennent dans la transformation d'un ensemble de chiers sources, constituant un pro-

    gramme, en un chier binaire excutable, qui est le rsultat de ce que l'on appelle communment

    la compilation. Il serait plus juste de dire les compilations suivies par les traductions d'assembleur

    en objet, suivies de la runion des chiers objets.

    Le compilateur de langage C se limite aux fonctionnalits qui

    peuvent tre traduites ecacement en instructions machine.

    La rgle de fonctionnement du compilateur C, dicte ci-dessus, permet de dtecter ce qui est

    fait directement par le compilateur lui-mme et ce qui ne peut l'tre. Essayons d'illustrer cette

    rgle par quelques exemples :

    Le compilateur C est capable de gnrer des instructions machine qui permettent de mani-

    puler des lments binaires(bits) ou des groupes d'lments binaires. Il peut donc raliser

    des masques pour slectionner des groupes de bits, ou encore faire des dcalages de bits

    l'intrieur de mots machine.

    Il permet les manipulations algbriques (addition, multiplication, etc.) de groupes d'octets

    qui reprsentent des valeurs entires ou des valeurs dcimales.

    cChristian Bac 1985-2003

  • CHAPITRE 1. HISTORIQUE ET PRSENTATION 3

    Il permet de manipuler des caractres en considrant qu'un caractre est reprsent par un

    octet partir du code ASCII

    2

    .

    Il ne permet pas de manipuler directement des tableaux. En particulier, il ne permet par de

    manipuler directement les groupes de caractres utiliss pour stocker les chanes de carac-

    tres. Pour cela, il faut faire appel des fonctions de bibliothques dont le nom commence

    par str comme strcat().

    De manire contradictoire la rgle prcdente, le compilateur accepte l'aectation d'une

    collection de donnes groupes (structure) par une collection de donnes de type identique,

    depuis la normalisation du langage. Ceci s'explique par le fait qu'une structure est considre

    dans le langage comme une donne simple, elle doit donc pouvoir tre aecte une autre

    donne de mme type.

    Pour raliser des oprations plus compliques, le programmeur doit crire ses propres fonctions

    ou faire appel aux fonctions prdnies de la bibliothque du langage C (voir chapitres 16 et

    17). Ces fonctions sont, elles aussi, standardises. La rdaction de la norme a supprim un petit

    problme qui venait de la rfrence sous-jacente aux oprations possibles sur le processeur du PDP

    11 de Digital Equipment sur lequel ont t conues les premires versions du compilateur C. Cette

    machine tait cependant susamment gnrale pour que cela ne transparaisse pas.

    1.3 Ides fondamentales

    Il est dicile de prsenter les dirents concepts du langage indpendemment les uns des autres,

    c'est pourquoi, certains concepts, comme la visibilit des variables, sont abords dans les premiers

    chapitres pour n'tre approfondis que plus tard.

    Nous allons dcrire les principales composantes d'un programme crit en langage C. Comme il

    est montr dans la gure 1.1, un programme en C est constitu d'un ensemble de chiers sources

    destins tre compils sparment et subir une dition de liens commune. Ces chiers sources

    sont aussi appels modules et ce type de programmation est appel programmation modulaire. Les

    notions de visibilits associes la programmation modulaire sont approfondies dans le chapitre

    9.

    Le fait de pouvoir compiler chaque chier source de manire autonome amne concevoir des

    programmes de manire modulaire en regroupant, dans chaque chier source, des fonctions qui

    manipulent les mmes variables ou qui participent aux mmes algorithmes.

    Chacune des parties peut tre regroupe dans un ou plusieurs chiers de langage C que l'on

    appelle aussi module.

    Prenons pour exemple un programme qui enregistre une srie de noms et notes d'lves. Chaque

    nom est associ une note. Une fois la saisie termine le programme trie la liste des lves par

    rang de note et ache cette liste ainsi trie. Puis il trie la liste des lves par ordre alphabtique

    partir de leurs noms et stocke cette liste dans un chier sur disque. Ce type d'application peut

    se dcouper en trois parties correspondant la gure 1.1 :

    la partie interactive qui change les informations avec l'utilisateur (fichier1.c ;

    la partie de calcul qui dans ce cas est un tri (par note ou par nom) (fichier2.c) ;

    la partie stockage des donnes sur disque une fois ces donnes tries (fichier3.c).

    Chaque chier (voir g. 1.2) contient les lments suivants dans un ordre quelconque :

    des rfrences des variables ou des fonctions externes (sous forme de dclarations). Ces

    rfrences dcrivent les types des variables ou le prototype des fonctions utilises dans ce

    module mais dnies dans d'autres modules ;

    des dnitions de variables globales et de fonctions, qui peuvent tre rfrences

    3

    dans les

    2

    ASCII : Americans Standard Code for Information Interchange. ISO 646 :1983, Information processing - ISO

    7-bit coded character set for information interchange.

    3

    Nous verrons plus en dtail l'ensemble des possibilits associes aux dclarations et aux dnitions dans les

    chapitres 3 et 9.

    cChristian Bac 1985-2003

  • 4 1.3. IDES FONDAMENTALES

    Fig. 1.1 Structure d'un programme C

    Fig. 1.2 Fichier source

    cChristian Bac 1985-2003

  • CHAPITRE 1. HISTORIQUE ET PRSENTATION 5

    Fig. 1.3 Structure d'une fonction C

    autres chiers ;

    des lignes de directives de compilation (pour le pr-processeur).

    Une fonction (Fig. 1.3) est construite partir :

    d'une interface constitue du type et du nom de la fonction suivis par les types et les noms

    de ses paramtres ;

    d'un bloc, appel aussi corps de la fonction.

    La fonction main() est particularise, en ce sens que l'excution du chier binaire excutable,

    conu partir de l'ensemble des chiers source, commence par elle.

    Un bloc est constitu :

    d'une accolade ouvrante ;

    des dnitions des variables locales au bloc ;

    des instructions ;

    d'une accolade fermante.

    Une instruction peut tre :

    un bloc

    4

    ;

    ou une expression

    5

    suivie d'un point virgule ( ;) ;

    ou une instruction de contrle de ot (test, boucle, rupture de squence).

    Nous parlerons en dtail des possibilits du pr-processeur dans le chapitre 15.

    1.4 En-chaneur de passes

    L'tude des direntes actions entreprises lors de ce que nous appelons de manire abusive la

    compilation, permet de mieux comprendre de quel outils proviennent les direntes caractris-

    tiques de la programmation en langage C.

    Nous prenons le cas des outils utiliss dans les systmes de type UNIX car les actions sont

    facilement sparables. Dans un systme de type UNIX, pour obtenir un chier excutable partir

    d'un source C, la commande usuelle est cc

    6

    :

    cc options nom_du_fichier.c

    Ces compilateurs sont en fait des en-chaneurs de passes ; nous allons voir l'usage, le fonc-

    tionnement, et les options de cc. Cet outils sert appeler les dirents utilitaires ncessaires

    la transformation d'un programme C en un chier excutable. L'en-chaneur de passes cc met en

    uvre cinq utilitaires :

    le pr-processeur, que nous appellerons cpp ;

    le compilateur C, que nous appellerons c0+c1 car il peut tre dcoup en deux parties ;

    4

    On voit apparatre une dnition rcursive l'intrieur du langage : savoir un bloc contient des instructions

    qui peuvent tre des blocs qui contiennent des instructions, . . .

    5

    Les expressions sont explicites dans le chapitre 5.

    6

    cc ou tout autre compilateur comme gcc.

    cChristian Bac 1985-2003

  • 6 1.4. EN-CHANEUR DE PASSES

    Fig. 1.4 Schma de fonctionnement de cc

    cChristian Bac 1985-2003

  • CHAPITRE 1. HISTORIQUE ET PRSENTATION 7

    l'optimiseur de code, appel c2 ;

    l'assembleur, que nous nommerons as ;

    l'diteur de liens, dont le nom le plus courant est ld.

    La gure1.4 donne un organigramme des direntes actions entreprises par un en-chaneur de

    passes. Les chiers temporaires de 1 3 dcrits dans cette gure sont utiliss par les outils pour

    stocker les donnes intermdiaires ncessaires la traduction des dirents codes.

    1.4.1 Pr-processeur

    Le pr-processeur ou pr-compilateur est un utilitaire qui traite le chier source avant le com-

    pilateur. C'est un manipulateur de chanes de caractres. Il retire les parties de commentaires, qui

    sont comprises entre /* et */. Il prend aussi en compte les lignes du texte source ayant un # en

    premire colonne pour crer le texte que le compilateur analysera. Ses possibilits sont de trois

    ordres (voir chap. 15) :

    inclusion de chiers ;

    dnition d'alias et de macro-expressions ;

    slection de parties de texte.

    1.4.2 Compilateur

    Le compilateur lit ce que gnre le pr-processeur et cre les lignes d'assembleur correspon-

    dantes. Le compilateur lit le texte source une seule fois du dbut du chier la n. Cette lecture

    conditionne les contrles qu'il peut faire, et explique pourquoi toute variable ou fonction doit tre

    dclare avant d'tre utilise.

    1.4.3 Optimiseur de code

    L'optimiseur de code limine les parties du code assembleur qui ne sont pas utiles. Il remplace

    des squences d'instructions par des instructions plus sophistiques et propres au processeur. Cette

    opration donne un code plus compact et plus rapide. Ensuite, il optimise les sauts. Dans les

    premires versions de compilateur, il est arriv que sur certaines machines l'optimisation cre de

    petits problmes qui se rsument par : aprs l'optimisation, le programme ne marche plus.

    1.4.4 Assembleur

    L'assembleur prend le code gnr par le compilateur, ventuellement modi par l'optimiseur,

    et gnre un chier en format relogeable. Ce chier possde des rfrences insatisfaites qui seront

    rsolues par l'diteur de liens. Sur les machines utilisant un systme de type UNIX, ce chier est

    sux par .o

    7

    .

    1.4.5 diteur de liens

    L'diteur de liens prend le ou les chiers en format relogeable et les associe pour crer un

    module chargeable. Il se sert de bibliothques pour rsoudre les rfrences indnies, en particulier

    la bibliothque standard (libc.a). Il utilise aussi un module spcial, crt0.o, qui contient le code

    de dmarrage du programme.

    Par dfaut sur un systme de type UNIX, l'diteur de lien met le rsultat de l'dition de liens

    dans un chier qu'il appelle a.out.

    7

    De mauvaises langues prtendent que sur d'autres types de systme un mauvais esprit aurait os les suxer

    par .OBJ

    cChristian Bac 1985-2003

  • 8 1.4. EN-CHANEUR DE PASSES

    1.4.6 Quelques options de cc

    La gure1.4 donne un schma de fonctionnement de cc, relativement aux options qui lui sont

    passes. Les options de l'enchaineur de passes sont prcdes d'un tiret

    8

    (-). Voici les options

    les plus couramment utilises :

    -c provoque la gnration d'un module objet non excutable, il s'arrte avant l'dition de liens.

    cc -c toto.c toto.o-E lance le pr-processeur seul, cpp, qui crit sur la sortie standard ou gnre un chier sux

    par .i.

    cc -E toto.c stdout ou toto.i-S gnre le chier assembleur aprs passage du pr-processeur et du compilateur. Le chier est

    sux par .s.

    cc -S toto.c toto.s-O optimise le code gnr (utilisation de c2).

    -o nom donne le nom au chier excutable au lieu de a.out.

    cc -o toto toto.c toto-v option bavarde, cc annonce ce qu'il fait.

    Deux options sont utiles sur le compilateur GNU gcc pour forcer la vrication d'une syntaxe

    correspondant la norme ANSI :

    -ansi avec cette option le compilateur se comporte comme un compilateur de langage C ANSI

    sans extensions de langage correspondant au C GNU ;

    -pedantic cette option demande au compilateur de refuser la compilation de programme non

    ansi ;

    -Wall cette option augmente le nombre de messages d'alerte gnrs par le compilateur lorsqu'il

    rencontre des constructions dangereuses.

    L'utilisation de ces options est recommande lors de l'apprentissage du langage C en utilisant le

    compilateur gcc.

    8

    Selon la tradition du systme UNIX.

    cChristian Bac 1985-2003

  • Chapitre 2

    Gnralits sur la syntaxe

    Ce chapitre introduit les premiers concepts indispensables la comprhension d'un programme

    C, savoir les rgles qui constituent la syntaxe de base du langage. Ces rgles sont utilises par

    les compilateurs pour dterminer si une srie de caractres correspond un mot rserv, un nom

    ou une constante.

    2.1 Mise en page

    Le format du texte est libre. La mise en page n'a aucune signication pour le compilateur. Elle

    est importante pour la lisibilit du programme. Les lignes de directives de pr-compilation (voir

    chapitre 15) commencent par un #.

    2.1.1 Identiant

    Les identiants sont utiliss pour donner des noms aux direntes entits utiliss dans le

    langage. Un identiant est construit selon le modle :

    partir de l'alphabet : a-z, A-Z, 0-9, _ ;

    il peut avoir jusqu' trente et un caractres signicatifs l'intrieur d'une unit de compi-

    lation. La norme mentionne que les noms peuvent tre limits six caractres entre units

    de compilation et que les diteurs de liens peuvent ne pas tenir compte des majuscules et

    minuscules. Cette contrainte n'est pas suivie par les compilateurs modernes.

    il commence par une lettre ou le soulign _.

    2.1.2 Espaces lexicaux

    Les dirents identiants d'un programme en langage C sont classs dans des espaces lexi-

    caux qui permettent d'isoler les noms selon leur signication. Les espaces lexicaux utiliss par un

    compilateur C sont les suivants :

    le premier espace contient les identiants relatifs aux types synonymes, aux variables et aux

    fonctions ;

    le second espace est rserv aux tiquettes pour les branchements inconditionnels ;

    le troisime espace est utilis pour les noms de modles de structures, d'unions ou d'num-

    rations ;

    pour chaque modle de structure ou d'union, un espace de noms est cr pour contenir les

    noms de champs de la structure ou de l'union.

    cChristian Bac 1985-2003

  • 10 2.2. MOTS RSERVS

    Ces espaces sont isols ce qui permet d'avoir une tiquette qui porte le mme nom qu'une variable

    mais jamais une fonction qui porte le mme nom qu'une variable.

    2.2 Mots rservs

    Ce sont les mots prdnis du langage C. Ils ne peuvent pas tre rutiliss pour des identiants.

    Ils sont relatifs aux dirents concepts du langage :

    type des donnes

    char const double float int long short signed unsigned void volatile

    classes d'allocation

    auto extern register static

    constructeurs

    enum struct typedef union

    instructions de boucle

    do for while

    slections

    case default else if switch

    ruptures de squence

    break continue goto return

    divers

    asm entry fortran sizeof

    2.3 Constantes

    Les constantes servent dans l'expression des tailles, l'initialisation des variables et dans les ex-

    pressions. Les constantes de type chane de caractres ont un statut particulier : elles permettent

    de constituer des tableaux de caractres anonymes. Les caractres de ces tableaux peuvent tre

    constants.

    Nous approfondirons l'expression des constantes dans la section 3.2 qui traite des types de

    variables. Voici cependant quelques exemples de constantes :

    constante entire : 10 ;

    constante ottante : 121.34 ;

    caractre simple : 'a' ;

    chane de caractres : "message".

    2.4 Instructions

    Une instruction est :

    soit une instruction simple,

    soit un instruction compose.

    Une instruction simple est toujours termine par un ;.

    Les instructions composes sont contenues entre deux accolades : {}.

    cChristian Bac 1985-2003

  • Chapitre 3

    Types et variables

    Ce chapitre traite des dnitions de variables. Dans tous les langages, une dnition de

    variable a les rles suivants :

    1. dnir le domaine de valeur de cette variable (taille en mmoire et reprsentation machine) ;

    2. dnir les oprations possibles sur cette variable ;

    3. dnir le domaine de visibilit de cette variable ;

    4. permettre l'environnement d'excution du programme d'associer le nom de la variable

    une adresse mmoire ;

    5. initialiser la variable avec une valeur compatible avec le domaine de valeur.

    En langage C, une variable se caractrise partir de son type et de sa classe mmoire. Les

    points prcdents numros 1 et 2 sont associs au type de la variable ; les points 3 et 4 sont associs

    la classe mmoire de la variable. L'initialisation est traite dans la section3.7.

    3.1 Types de base

    Ce sont les types prdnis du compilateur. Ils sont au nombre de six :

    void c'est le type vide. Il a t introduit par la norme ANSI. Il est surtout utilis pour prciser

    les fonctions sans argument ou sans retour. Il joue un rle particulier dans l'utilisation des

    pointeurs (voir chapitre 10).

    int c'est le type entier. Ce type se dcline avec des qualicatifs pour prciser sa taille (long ou

    short), et le fait qu'il soit uniquement positif (unsigned) ou positif et ngatif (signed)

    1

    . Le

    qualicatif signed est appliqu par dfaut, ainsi il n'y a pas de dirence entre une variable

    de type int et une variable de type signed int.

    char ce type est trs proche de l'octet. Il reprsente un entier sur huit bits. Sa valeur peut voluer

    entre -128 et +127. Il est le support des caractres au sens commun du terme. Ces caractres

    sont reprsents par la table ASCII. Comme le type int le type char peut tre quali de

    manire tre sign ou non. La norme ANSI introduit un type permettant de supporter des

    alphabets comprenant plus de 255 signes, ce type est appel wchar_t. Il est dni dans le

    chier.

    float ce type sert pour les calculs avec des parties dcimales.

    double c'est un type qui permet de reprsenter des valeurs ayant une partie dcimale avec une plus

    grande prcision que le type float. Comme nous le verrons dans l'expression des constantes

    1

    Dans le cas le plus courant une variable du type entier peut contenir une valeur positive ou ngative.

    cChristian Bac 1985-2003

  • 12 3.1. TYPES DE BASE

    (sec. 3.2.2) et dans les calculs(sec. 3.8), ce type est le plus courant pour reprsenter des

    valeurs avec parties dcimales.

    long double ce type est rcent, il permet de reprsenter des nombres avec parties dcimales qui

    ncessitent une trs grande prcision.

    3.1.1 Types entiers

    Les mots short et long peuvent tre utiliss seuls ou avec le mot int, donnant la possibilit

    d'avoir des dnitions du type : short int ou long int. Ces dnitions peuvent aussi s'crire de

    manire abrge : short ou long.

    Le langage C considre les types char, short int, int et long int, comme des types entiers

    et permet de les mlanger lors des calculs (5.3).

    A priori, les types entiers sont signs, c'est--dire qu'ils peuvent contenir des valeurs positives

    ou ngatives. Par exemple, la valeur d'une variable du type char peut voluer entre -128 et +127.

    Les types entiers peuvent tre qualis l'aide du mot unsigned qui force les variables de

    ce type tre considres comme uniquement positives. Par exemple, la valeur d'une variable du

    type unsigned char ne peut voluer qu'entre 0 et 255.

    Le qualicatif signed permet d'insister sur le fait que la variable peut prendre des valeurs

    positives ou ngatives. Il fait pendant au qualicatif unsigned comme l'oprateur + unaire fait

    pendant l'oprateur - unaire.

    3.1.2 Types avec parties dcimales

    Comme nous l'avons dj dit, les types avec parties dcimales sont au nombre de trois :

    float ce type sert pour les calculs avec des parties dcimales. Il est souvent reprsent selon la

    norme ISO/IEEE 754.

    double ce type de plus grande prcision permet de reprsenter des valeurs avec parties dcimales.

    Lui aussi est souvent bas sur la norme ISO/IEEE 754.

    long double ce type est rcent et permet de reprsenter des nombres avec parties dcimales sur

    une trs grande prcision, si la machine le permet.

    3.1.3 Tailles des types

    L'espace qu'occupent les dirents types en mmoire dpend de la machine sur laquelle est

    implant le compilateur. Le choix est laiss aux concepteurs des compilateurs. Les seules contraintes

    sont des ingalits non strictes, savoir :

    sizeof(short) sizeof(int) sizeof(long) sizeof(float) sizeof(double) sizeof(longdouble)o sizeof est un oprateur qui donne la taille en nombre d'octets du type dont le nom est entre

    parenthses.

    La taille de l'entier est le plus souvent la taille des registres internes de la machine, c'est

    par exemple seize bits sur une machine de type ordinateur personnel

    2

    et trente-deux bits sur les

    machines du type station de travail.

    La taille des variables ayant une partie dcimale est le plus souvent cadre sur la norme

    ISO/IEEE 754. Les machines supportant un type long double dirent du type double sont

    assez rares.

    2

    Pour des problmes de compatibilit avec les anciennes versions, les compilateurs pour PC gnrent le plus

    souvent du code compatible 386.

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 13

    Type PDP 11 Intel 486 Sparc Pentium Alpha

    Anne 1970 1989 1993 1993 1994

    char 8 bits 8bits 8bits 8bits 8bits

    short 16 bits 16 bits 16 bits 16 bits 16 bits

    int 16 bits 16 bits 32 bits 32 bits 32 bits

    long 32 bits 32 bits 32 bits 32 bits 64 bits

    oat 32 bits 32 bits 32 bits 32 bits 32 bits

    double 64 bits 64 bits 64 bits 64 bits 64 bits

    long double 64 bits 64 bits 64 bits 64 bits 128 bits

    Tab. 3.1 Longueur des types de base sur quelques machines

    Le tableau 3.1 donne quelques exemples de tailles pour des machines dont les registres ont les

    tailles suivantes en nombre de bits : 16 (DEC PDP11, Intel 486), 32 (SUN Sparc, Intel Pentium) et

    64 (DEC Alpha). Vous remarquerez que malgr son architecture interne de 64 bits, le compilateur

    pour alpha utilise des entiers sur 32 bits. Il est aussi le seul processeur capable de direncier les

    double des long doubles.

    3.2 Constantes associes aux types de base

    Les constantes sont reconnues par le compilateur grce l'utilisation de caractres qui ne

    participent pas la construction d'un identiant.

    3.2.1 Constantes de type entier

    Les constantes de type entier sont construites partir de chires. Elles sont naturellement

    exprimes en base dix mais peuvent tre exprimes en base huit (octal) lorsque le premier caractre

    est un 0 ou en base seize lorsque les deux premiers caractres sont 0X (hexadcimal).

    Une constante est a priori du type int si le nombre qu'elle reprsente est plus petit que le

    plus grand entier reprsentable. Si la valeur de la constante est suprieure au plus grand entier

    reprsentable, la constante devient du type long.

    Les constantes peuvent tre suxes par un l ou L pour prciser que leur type associ est

    long int.

    Les constantes peuvent tre prcdes par un signe - ou +.

    Elles peuvent tre suxes par un u ou U pour prciser qu'elles expriment une valeur sans

    signe (qualies unsigned).

    Voici quelques exemples de constantes de type entier :

    constante sans prcision de type :

    0377 octal

    0X0FF hexadcimal

    10 dcimal

    -20 dcimal

    constante longue entire :

    1. 120L, 0364L, 0x1faL

    2. 120l, 0364l, 0x1fal

    constante entire non signe :

    1. 120U, 0364U, 0x1faU

    cChristian Bac 1985-2003

  • 14 3.2. CONSTANTES ASSOCIES AUX TYPES DE BASE

    2. 120u, 0364u, 0x1fau

    constante longue entire non signe :

    1. 120UL, 0364UL, 0x1faUL, 120uL, 0364uL, 0x1fauL

    2. 120Ul, 0364Ul, 0x1faUl, 120ul, 0364ul, 0x1faul

    3.2.2 Constantes avec partie dcimale

    Les constantes avec partie dcimale ont le type double par dfaut. Elles peuvent tre exprimes

    partir d'une notation utilisant le point dcimal ou partir d'une notation exponentielle.

    Ces constantes peuvent tre suxes par un f ou F pour prciser qu'elles reprsentent une

    valeur de type float.

    Elles peuvent de mme tre suxes par un l ou un L pour exprimer des valeurs de type

    long double.

    Voici quelques constantes avec partie dcimale :

    121.34 constante exprime avec la notation utilisant le point dcimal, son type implicite est

    double.

    12134e-2 la mme constante exprime en notation exponentielle

    +12134E-2 la notation exponentielle accepte le E majuscule, et le + un-aire.

    121.34f constante de valeur identique mais de type float car suxe par f.

    121.34l constante de valeur identique mais de type long double car suxe par l.

    3.2.3 Constantes de type caractre

    Les constantes du type caractre simple sont toujours entoures d'apostrophes (single quote).

    Elles peuvent tre reprsentes selon quatre mthodes :

    1. lorsque le caractre est disponible au clavier sauf pour la barre de fraction inverse et l'apos-

    trophe, le caractre correspondant est simplement entour d'apostrophes, par exemple 'a'.

    2. un caractre peut aussi tre reprsent par sa valeur exprime dans la table ASCII en utilisant

    une notation en base huit. Cette valeur est prcde l'intrieur des apostrophes par une

    barre de fraction inverse.

    '\0' : octet du nul, il sert dlimiter les ns de chanes de caractres.'\012' : saut de ligne (Line Feed, LF) ;'\015' : retour chariot (Carriage Return, CR) ;'\011' : tabulation horizontale (Horizontal Tabulation, HT) ;3. de mme, un caractre peut tre reprsent par sa notation en base seize.

    '\x0' : caractre nul ;'\xA' : saut de ligne (LF) ;'\xC' : retour chariot (CR) ;'\x9' : tabulation horizontale (HT) ;4. un certain nombre d'abrviations est aussi disponible :

    '\a' : alert (sonnerie, BEL) ;'\b' : backspace (BS) ;'\f' : saut de page (FF) ;'\n' : saut de ligne (LF) ;

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 15

    Fig. 3.1 Chane de caractres constante

    '\r' : retour chariot (CR) ;'\t' : tabulation horizontale (HT) ;'\v' : tabulation verticale (VT) ;Pour spcier qu'une constante caractre est du type (wchar_t), elle doit tre prcde d'un

    L. Par exemple, L'a' est la constante de type caractre long contenant le caractre a.

    3.2.4 Chanes de caractres

    Les constantes du type chane de caractres doivent tre mises entre guillemets (double quote).

    Le compilateur gnre une suite d'octets termine par un caractre nul (tous les bits 0) partir

    des caractres contenus dans la chane. Cette suite d'octets peut tre place par le systme dans

    une zone de mmoire en lecture seulement.

    La zone correspondante est en fait un tableau de char. La chane est rfrence par l'adresse

    du tableau. Par exemple, la chane de caractres "message" est gnre par le compilateur selon

    le schma de la gure 3.1.

    3.3 Qualicatifs

    Nous avons dj parl des qualicatifs unsigned et signed qui s'appliquent aux variables de

    type entier. Il existe d'autres qualicatifs qui ont t spcis par la norme. Il s'agit de const,

    volatile, static et register.

    Une dnition de variable qualie du mot const informe le compilateur que cette variable est

    considre comme constante et ne doit pas tre utilise dans la partie gauche d'une aectation. Ce

    type de dnition autorise le compilateur placer la variable dans une zone mmoire accessible

    en lecture seulement l'excution.

    Le qualicatif volatile informe le compilateur que la variable correspondante est place dans

    une zone de mmoire qui peut tre modie par d'autres parties du systme que le programme

    lui-mme. Ceci supprime les optimisations faites par le compilateur lors de l'accs en lecture de

    la variable. Ce type de variable sert dcrire des zones de mmoire partages entre plusieurs

    programmes ou encore des espaces mmoires correspondant des zones d'entre-sorties de la

    machine.

    Les deux qualicatifs peuvent tre utiliss sur la mme variable, spciant que la variable n'est

    pas modie par la partie correspondante du programme mais par l'extrieur.

    Les qualicatifs static et register sont dcrits dans la section 3.5.

    3.4 Taille et normalisation

    Les tailles des types entiers et avec partie dcimale sont dnies sur chaque machine partir

    de deux chiers :

    limits.h pour les types entiers ;

    float.h pour les types avec partie dcimale.

    cChristian Bac 1985-2003

  • 16 3.5. DFINITION DE VARIABLES

    Ces chiers contiennent des dnitions qui s'adressent au pr-compilateur et donnent les tailles

    et valeurs maximales des types de base et des types non signs.

    Le programme 3.1 est un exemple de chier et le programme 3.2 est un exemple

    de chier .

    Programme 3.1 Exemple de chier limits.h

    /* Number of bits in a char. */

    #define CHAR_BIT 8

    /* No multibyte characters supported yet. */

    #define MB_LEN_MAX 1

    /* Min and max values a signed char can hold. */

    #define SCHAR_MIN (-128)

    #define SCHAR_MAX 127

    /* Max value an unsigned char can hold. (Min is 0). */

    #define UCHAR_MAX 255U

    /* Min and max values a char can hold. */

    #define CHAR_MIN SCHAR_MIN

    #define CHAR_MAX SCHAR_MAX

    /* Min and max values a signed short int can hold. */

    #define SHRT_MIN (-32768)

    #define SHRT_MAX 32767

    /* Max value an unsigned short int can hold. (Min is 0). */

    #define USHRT_MAX 65535U

    /* Min and max values a signed int can hold. */

    #define INT_MIN (-INT_MAX-1)

    #define INT_MAX 2147483647

    /* Max value an unsigned int can hold. (Min is 0). */

    #define UINT_MAX 4294967295U

    /* Min and max values a signed long int can hold. */

    #define LONG_MIN (-LONG_MAX-1)

    #define LONG_MAX 2147483647

    /* Max value an unsigned long int can hold. (Min is 0). */

    #define ULONG_MAX 4294967295U

    La normalisation a aussi introduit un ensemble de types prdnis comme size_t qui est le

    type de la valeur retourne par l'oprateur sizeof. Les dnitions exactes de ces types sont dans

    le chier . Le programme 3.3 est un extrait d'un exemple de chier .

    3.5 Dnition de variables

    Nous appellerons identiant soit un nom de fonction, soit un nom de variable. Pour complter

    ce que nous avons dit dans l'introduction de ce chapitre, voici comment les dirents besoins

    associs la dnition de variables sont couverts par le langage C :

    dnition du domaine de valeur de cette variable et les oprations lgales sur cette variable ;

    = grce au type.

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 17

    Programme 3.2 Exemple de chier float.h

    /* Float definitions */

    #define FLT_MANT_DIG 24

    #define FLT_EPSILON 1.19209290e-07f

    #define FLT_DIG 6

    #define FLT_MIN_EXP -125

    #define FLT_MIN 1.17549435e-38f

    #define FLT_MIN_10_EXP -37

    #define FLT_MAX_EXP 128

    #define FLT_MAX 3.40282347e+38f

    #define FLT_MAX_10_EXP 38

    /* Double definitions */

    #define DBL_MANT_DIG 53

    #define DBL_EPSILON 2.2204460492503131e-16

    #define DBL_DIG 15

    #define DBL_MIN_EXP -1021

    #define DBL_MIN 2.2250738585072014e-308

    #define DBL_MIN_10_EXP -307

    #define DBL_MAX_EXP 1024

    #define DBL_MAX 1.79769313486231570e+308

    #define DBL_MAX_10_EXP 308

    Programme 3.3 Exemple de chier stddef.h

    typedef long ptrdiff_t;

    typedef unsigned long size_t;

    typedef int wchar_t;

    rservation de l'espace mmoire ncessaire au support de la variable lors de l'excution ;

    = grce au type et la classe mmoire.initialisation de la variable l'aide d'une constante dont le type correspond celui de la va-

    riable ;

    = en faisant suivre le nom par un symbole d'aectation = et une valeur compatible avecla variable.

    association d'une dure de vie la variable qui permet l'utilisation dans certaines parties du

    programme (rgles de visibilit).

    = grce la classe mmoire et au lieu de dnition.Une dnition de variable est l'association d'un identiant un type et la spcication d'une

    classe mmoire. La classe mmoire sert expliciter la visibilit d'une variable et son implantation

    en machine. Nous approfondirons les possibilits associes aux classes mmoire dans le chapitre 9

    sur la visibilit. Les classes mmoire sont :

    global cette classe est celle des variables dnies en dehors d'une fonction. Ces variables sont

    accessibles toutes les fonctions. La dure de vie des variables de type global est la mme

    que celle du programme en cours d'excution.

    local ou auto : cette classe comprend l'ensemble des variables dnies dans un bloc. C'est le cas

    de toute variable dnie l'intrieur d'une fonction. L'espace mmoire rserv pour ce type

    de variable est allou dans la pile d'excution. C'est pourquoi elles sont appeles aussi auto

    c.a.d automatique car l'espace mmoire associ est cr lors de l'entre dans la fonction et

    cChristian Bac 1985-2003

  • 18 3.6. TYPES DRIVS DES TYPES DE BASE

    Dclaration/dnition Classe mmoire

    int a ; dnition d'une variable globale

    int

    main (int argc, paramtres passs dans la pile,

    char *argv[]) donc automatiques

    {

    int b ; dnition d'une variable locale main donc automatique

    static char c[50] ; variable locale main mais implante avec les globales

    }

    extern int b ; dclaration d'une variable qui est dnie dans un autre chier

    int (rien voir la variable b de main), variable globale externe

    coucou(const int c) paramtre constant, variable locale

    { la fonction coucou s'engage ne pas modier c

    volatile char c ; variable locale volatile

    register int a ; variable locale coucou, mettre en registre si possible

    if (b == 1) rfrence la variable b externe

    }

    Tab. 3.2 Variables et classes mmoire

    il est dtruit lors de la sortie de la fonction. La dure de vie des variables de type local est

    celle de la fonction dans laquelle elles sont dnies.

    static ce qualicatif modie la visibilit de la variable, ou son implantation :

    dans le cas d'une variable locale il modie son implantation en attribuant une partie de

    l'espace de mmoire globale pour cette variable. Une variable locale de type statique a un

    nom local mais a une dure de vie gale celle du programme en cours d'excution.

    dans le cas d'une variable globale, ce prdicat restreint la visibilit du nom de la variable

    l'unit de compilation. Une variable globale de type statique ne peut pas tre utilise

    par un autre chier source participant au mme programme par une rfrence avec le mot

    rserv extern (voir point suivant).

    extern ce qualicatif permet de spcier que la ligne correspondante n'est pas une tentative de

    dnition mais une dclaration (voir 3.9). Il prcise les variables globales (noms et types)

    qui sont dnies dans un autre chier source et qui sont utilises dans ce chier source.

    register ce qualicatif permet d'informer le compilateur que les variables locales dnies dans

    le reste de la ligne sont utilises souvent. Le prdicat demande de les mettre si possible

    dans des registres disponibles du processeur de manire optimiser le temps d'excution. Le

    nombre de registres disponibles pour de telles demandes est variable selon les machines. Il

    est de toute faon limit (4 pour les donnes, 4 pour les pointeurs sur un 680X0). Seules les

    variables locales peuvent tre qualies register.

    Le tableau 3.2 donne quelques exemples de dnitions et dclarations de variables.

    3.6 Types drivs des types de base

    Un type driv est cr partir des types de base vus prcdemment pour l'usage propre un

    programme. Les types drivs sont les tableaux, les structures et les pointeurs.

    3.6.1 Tableaux et structures

    Les tableaux sont des paquets de donnes de mme type. Ils sont reconnus par la prsence

    de crochets ouvrants et fermants lors de la dclaration ou de la dnition de l'objet. La taille du

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 19

    tableau est donne entre les crochets lors de la dnition. Pour simplier le travail du compilateur,

    le rang des lments du tableau ne peut voluer qu'entre 0 et la taille du tableau -1.

    Les structures sont des ensembles de donnes non homognes. Les donnes peuvent avoir des

    types dirents. Les structures sont dclares ou dnies selon le modle :

    struct

    un nom de structure facultatif

    {

    la liste des donnes contenues dans la structure

    }

    la liste des variables construites selon ce modle.

    Prenons pour exemple les dnitions suivantes :

    int tab[10];

    struct st1 {

    int a1;

    float b1;

    long c1;

    } objst1;

    Dans cet exemple :

    1. tab est un tableau de 10 entiers, et les lments du tableau sont rfrencs par tab[0]

    jusqu' tab[9] ;

    2. st1 est un nom de modle de structure et objst1 est un objet de type struct st1. Les

    direntes parties de la structure objst1 sont accessibles par objst1.a1, objst1.b1 et

    objst1.c1.

    Les tableaux et les structures sont parfois appels agglomrats de donnes.

    3.6.2 Pointeurs

    Le pointeur est une variable destine contenir une adresse mmoire. Le compilateur connais-

    sant la taille de l'espace adressable de la machine, il sait la taille ncessaire pour contenir un

    pointeur. Un pointeur est reconnu syntaxiquement par l'toile (symbole de la multiplication *) qui

    prcde son nom dans sa dnition.

    Tout pointeur est associ un type d'objet. Ce type est celui des objets qui sont manipulables

    grce au pointeur. Ce type est utilis en particulier lors des calculs d'adresse qui permettent de

    manipuler des tableaux partir de pointeurs (voir Chap. 10).

    Prenons les dnitions suivantes :

    int *ptint;

    char *ptchar;

    Dans cet exemple, ptint est une variable du type pointeur sur un entier. Cette variable

    peut donc contenir des

    3

    valeurs qui sont des adresses de variables du type entier (int).

    De mme, ptchar est une variable du type pointeur sur un caractre. Elle peut donc contenir

    des valeurs qui sont des adresses de variables de type caractre (char).

    Le compilateur C vrie le type des adresses mises dans un pointeur. Le type du pointeur

    conditionne les oprations arithmtiques (voir chap. 9 pointeurs et tableaux) sur ce pointeur.

    Les oprations les plus simples sur un pointeur sont les suivantes :

    3

    Une valeur la fois mais comme le pointeur est une variable cette valeur peut changer au cours de l'excution

    du programme.

    cChristian Bac 1985-2003

  • 20 3.7. INITIALISATION DE VARIABLES

    aectation d'une adresse au pointeur ;

    utilisation du pointeur pour accder l'objet dont il contient l'adresse.

    Si l'on dnit les variables de la manire suivante :

    int in;

    int tabint[10];

    char car;

    int *ptint;

    char *ptchar;

    Un pointeur peut tre aect avec l'adresse d'une variable ayant un type qui correspond celui

    associ au pointeur. Comme nous le verrons dans la partie sur les oprateurs, le -commercial &

    donne l'adresse du nom de variable qui le suit et les noms de tableau correspondent l'adresse

    du premier lment du tableau. Les pointeurs prcdents peuvent donc tre aects de la manire

    suivante :

    ptint = ∈

    ptc = &car;

    Une fois un pointeur aect avec l'adresse d'une variable, ce pointeur peut tre utilis pour

    accder aux cases mmoires correspondant la variable (valeur de la variable) :

    *ptint = 12;

    *ptc = 'a';

    La premire instruction met la valeur entire 12 dans l'entier in ; la deuxime instruction met

    le caractre a minuscule dans l'entier car.

    Il est possible de raliser ces oprations en utilisant le pointeur pour accder aux lments du

    tableau. Ainsi les lignes :

    ptint=tab;

    *ptint=4;

    aectent le pointeur ptint avec l'adresse du premier lment du tableau tabint quivalent (comme

    nous le reverrons dans le chapitre sur pointeurs et tableaux 10) &tabint[0] ; puis le premier

    lment du tableau (tabint[0]) est aect avec la valeur 4.

    3.7 Initialisation de variables

    L'initialisation se dnit comme l'aectation d'une valeur lors de la dnition de la variable.

    Toute modication de valeur d'une variable postrieure sa dnition n'est pas une initialisa-

    tion mais une aectation.

    Par dfaut, les variables de type global (dnies en dehors de toute fonction) sont initialises

    avec la valeur qui correspond tous les bits zro (0 pour un entier ou 0.0 pour un nombre

    virgule ottante). Les variables locales, quant elles ne sont pas initialises avec des valeurs

    par dfaut. Vous veillerez donc les initialiser pour vous prmunir contre le risque d'utiliser une

    variable sans en connatre la valeur initiale. Sur les compilateurs anciens, pour les variables de

    type tableau ou structure, seules les variables globales pouvaient tre initialises.

    Il est possible de raliser des initialisations selon trois techniques suivant le type de la variable :

    1. dans le cas d'une variable simple, il sut de faire suivre la dnition du signe gal (=) et de

    la valeur que l'on veut voir attribue la variable.

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 21

    int i = 10; Entier i initialis 10

    int j = 12, entiers j initialis 12 ;

    k = 3, l; k initialis 3 et l non initialis.

    int *p1 = &i; Pointeur d'entier initialis l'adresse de i

    char d = '\n'; Caractre initialis la valeur du retour chariot.

    float tf[10] = { Tableau de dix ottants dont les quatre premiers

    3.1, 4.5, 6.4, sont initialiss 3.1 4.5 6.4

    9.3 }; et 9.3, les autres sont initialiss 0.0.

    char t1[10] = Tableau de 10 caractres initialis avec les caractres

    "Coucou"; 'C' 'o' 'u' 'c' 'o' 'u' '\0'

    Les trois derniers caractres sont aussi

    initialiss avec la valeur '\0'.

    struct tt1{ modle de structure contenant

    int i; un entier,

    float j; un ottant,

    char l[20]; et un tableau de 20 caractres.

    } obst = { variable (obst) du type struct tt1,

    12, avec le premier champ (obst.i) initialis 12,

    3.14, le deuxime champ (obst.j) initialis 3.14,

    "qwertyuiop" }; et le troisime champ (obst.l) initialis partir

    de la chane "qwertyuiop"

    char t2[] = Tableau de caractres initialis avec la chane

    "bonjour"; "bonjour". La taille du tableau est calcule

    selon le nombre de caractres + 1 (pour le nul).

    char t3[10] = { 'a', Tableau de 10 caractres dont les 5 premiers sont

    'b','c','d','e'}; initialiss.

    const char *p3 = Pointeur sur un caractre initialis l'adresse de

    "Bonjour les"; la chane de caractres constante. La chane peut tre mise

    dans une zone de mmoire accessible en lecture seulement.

    Tab. 3.3 Exemples d'initialisations

    2. dans le cas de tableaux ou structures, il faut faire suivre la dnition du signe gal suivi

    d'une accolade ouvrante et de la srie de valeurs termine par une accolade fermante. Les

    valeurs sont spares par des virgules. Elles doivent correspondre aux lments du tableau

    ou de la structure. La norme prconise que lorsque le nombre de valeurs d'initialisation est

    infrieur au nombre d'lments initialiser, les derniers lments soient initialiss avec la

    valeur nulle correspondant leur type.

    3. les tableaux de caractres peuvent tre initialiss partir d'une chane de caractres. Les

    caractres de la chine sont considrs comme constants.

    Le tableau 3.3 donne des exemples d'initialisation.

    3.8 Conversion de type

    La conversion de type est un outil trs puissant, elle doit donc tre utilise avec prudence.

    Le compilateur fait de lui-mme des conversions lors de l'valuation des expressions. Pour cela il

    applique des rgles de conversion implicite. Ces rgles ont pour but la perte du minimum d'infor-

    mation dans l'valuation de l'expression. Ces rgles sont dcrites dans l'encart ci-dessous.

    cChristian Bac 1985-2003

  • 22 3.8. CONVERSION DE TYPE

    float f ; double d ; int i ; long li ;

    li = f + i ; i est transform en oat puis additionn f,

    le rsultat est transform en long et rang dans li.

    d = li + i ; i est transform en long puis additionn li,

    le rsultat est transform en double et rang dans d.

    i = f + d ; f est transform en double, additionn d,

    le rsultat est transform en int et rang dans i.

    Tab. 3.4 Exemples de conversion implicite

    Rgle de Conversion Implicite

    Convertir les lments de la partie droite d'une expression d'aectation

    dans le type de la variable ou de la constante le plus riche.

    Faire les oprations de calcul dans ce type.

    Puis convertir le rsultat dans le type de la variable aecte.

    La notion de richesse d'un type est prcise dans la norme [ISO89]. Le type dans lequel le

    calcul d'une expression deux oprandes doit se faire est donn par les rgles suivantes :

    1. si l'un des deux oprandes est du type long double alors le calcul doit tre fait dans le type

    long double ;

    2. sinon, si l'un des deux oprandes est du type double alors le calcul doit tre fait dans le

    type double ;

    3. sinon, si l'un des deux oprandes est du type float alors le calcul doit tre fait dans le type

    float ;

    4. sinon, appliquer la rgle de promotion en entier, puis :

    (a) si l'un des deux oprandes est du type unsigned long int alors le calcul doit tre fait

    dans ce type ;

    (b) si l'un des deux oprandes est du type long int alors le calcul doit tre fait dans le

    type long int ;

    (c) si l'un des deux oprandes est du type unsigned int alors le calcul doit tre fait dans

    le type unsigned int ;

    (d) si l'un des deux oprandes est du type int alors le calcul doit tre fait dans le type int.

    3.8.1 Conversions implicites

    Le C selon la rdaction de Kernighan et Ritchie dcrivait la faon avec laquelle les variables

    taient promues lors des appels de fonction. Cette rgle porte d'une part sur les nombres virgule

    ottante qui sont transfoms en double, et d'autre part sur tous les types entier dont la taille est

    plus petite que l'entier naturel. Les variables ou les constantes des types suivants sont utilises

    dans une expression, les valeurs de ces variables ou constantes sont transformes en leur quivalent

    en entier avant de faire les calculs. Ceci permet d'utiliser des caractres, des entiers courts, des

    champs de bits et des numrations de la mme faon que des entiers. Le principe permet d'utiliser

    la place d'un entier :

    des caractres et des entiers courts signs ou non signs ;

    des champs de bits et des numrations signs ou non signs.

    Des exemples de conversions implicites sont donns dans le tableau3.4.

    Il est possible de forcer la conversion d'une variable (ou d'une expression) dans un autre type

    avant de l'utiliser par une conversion implicite. Cette opration est appele cast. Elle se ralise

    de la manire suivante :

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 23

    (type) expression

    Prenons pour exemple l'expression : i = (int) f + (int) d ;

    f et d sont convertis en int, puis additionns. Le rsultat entier est rang dans i.

    Il peut y avoir une dirence entre

    i = f + d ;

    et

    i = (int) f + (int) d ;

    du fait de la perte des parties fractionnaires.

    3.9 Dclaration et dnition

    Maintenant que nous connaissons les dirents types du langage C, nous pouvons introduire

    la dirence entre dclaration et dnition. Cette dirence sera vue de manire approfondie dans

    le chapitre 9. Nous appellerons :

    dclaration : une association de type avec un nom de variable ou de fonction (dans ce cas

    la dclaration contient aussi le type des arguments de la fonction, les noms des arguments

    peuvent tre omis),

    dnition : une dclaration et si c'est une variable, une demande d'allocation d'espace

    pour cette variable, si c'est une fonction la dnition du corps de fonction contenant les

    instructions associes cette fonction.

    De manire simpliste, une dclaration fait rfrence une dnition dans une autre partie du

    programme. Elle peut se traduire par je sais qu'il existe une variable ayant ce type et portant ce

    nom.

    3.10 Exercices sur les types et variables

    3.10.1 Exercice 1

    Dans un chier appel exo1.c, dclarer les variables suivantes :

    chane de 10 caractres globale et statique ;

    tableau de 10 entiers global ;

    pointeur sur caractre local en registre ;

    ottant local ;

    caractre local statique ;

    entier nomm ex externe.

    Dans la fonction main(), faire crire les adresses des variables.

    Compiler avec : gcc -c exo1.c

    Dans un deuxime chier appel exo1bis.c mettre la dnition de l'entier ex que vous initia-

    liserez avec la valeur 20.

    Compiler ce deuxime chier de la mme manire : gcc -c exo1bis.c

    Faire l'dition de liens par : gcc -o exo1 exo1.o exo1bis.o

    3.10.2 Exercice 2

    Dans un chier appel exo2.c, dclarer les variables suivantes :

    un entier global initialis 10 ;

    un tableau de 10 caractres global initialis "bonjour" ;

    cChristian Bac 1985-2003

  • 24 3.10. EXERCICES SUR LES TYPES ET VARIABLES

    Programme 3.4 Suggestion de corrig chapitre 3 exercice 1

    1 static char chaine[10];

    2 int tableau[10];

    3 extern int ex;

    4 int

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

    6 register char *pointeur;

    7 float local;

    8 static char car;

    9 return 0;

    10 }

    Programme 3.5 Suggestion de corrig chapitre 3 exercice 1 second chier

    1

    2 int ex = 20;

    un pointeur sur caractre initialis l'adresse du premier lment du tableau.

    Compiler, essayer de mettre l'adresse de l'entier dans le pointeur de caractre et regardez les

    messages d'erreurs.

    Une fois que vous aurez lu le chapitre 4 sur les lments de bases pour raliser les premiers

    programmes, faire crire le tableau partir de son nom et avec le pointeur.

    Programme 3.6 Suggestion de corrig chapitre 3 exercice 2

    1 /* declaration des variables globales */

    2 int global = 10;

    3 char tableau[10] = "bonjour";

    4 int

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

    6 char *pt = tableau; /* ou pt = & tableau[0] */

    7 pt = (char *) &global; /* adresse de l entier dans le pointeur de char */

    8 pt = tableau; /* adresse du tableau dans le pointeur */

    9 printf("%s\n", tableau);

    10 printf("%s\n", pt);

    11 return 0;

    12 }

    Donnes crites sur le fichier standard de sortie

    bonjour

    bonjour

    3.10.3 Exercice 3

    Dclarer :

    un entier i ;

    un ottant f ;

    un pointeur sur caractre ptc ;

    un pointeur sur entier pti ;

    un tableau d'entier ti ;

    cChristian Bac 1985-2003

  • CHAPITRE 3. TYPES ET VARIABLES 25

    un tableau de caractres tc.

    Raliser les oprations suivantes :

    i = f ;

    f = i ;

    pti = 0 ;

    ptc = pti ;

    pti = tc ;

    ptc = ti.

    Compiler.

    Faire les "casts" ncessaires une compilation sans erreurs.

    Programme 3.7 Suggestion de corrig chapitre 3 exercice 3

    1 int

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

    3 /* declarations des variables */

    4 int i;

    5 float f;

    6 char *ptc;

    7 int *pti;

    8 int ti[10];

    9 char tc[10];

    10 /* affectations des variables */

    11 i = f;

    12 f = i;

    13 pti = 0;

    14 ptc =