Vous êtes sur la page 1sur 217

Module Langage de programmation structure

Module Langage de programmation structure

Page 1 sur 217

Module Langage de programmation structure

I.
I.

Table des matires


Table des matires ......................................................... 2
A. B. A. A.
1. 2. 3.

II. Introduction aux Langages de programmation ............. 14


Introduction........................................................................... 14 La compilation........................................................................ 14 Exemple ................................................................................ 14 La fonction main..................................................................... 18
Dfinition de la fonction main en C.................................................... 18 Rsultat de main ............................................................................ 18 Paramtres de main ........................................................................ 18

III.Premier programme en C.............................................. 14 IV. Notion de base ............................................................. 18

B.
a) b)

Les variables.......................................................................... 18
Exemples : ............................................................................................ 19 Exercice1 : ............................................................................................ 19

1. Les identificateurs........................................................................... 18

C. D.

Les commentaires .................................................................. 19 Discussion de l'exemple 'Hello_World' ....................................... 20

1. Discussion ..................................................................................... 20 2. printf et la bibliothque <stdio> ....................................................... 20


a) b) c) Exercice 2 ............................................................................................. 20 Exercice 3 ............................................................................................. 21 Exercice 4 ............................................................................................. 21

E.
1. 2. 3. 4.

Correction des exercices .......................................................... 22


Exercice Exercice Exercice Exercice 1...................................................................................... 2...................................................................................... 3...................................................................................... 4...................................................................................... 22 22 22 23

V. Types de base, oprateurs et expressions .................... 23


A. B.
a) b) c)

Introduction........................................................................... 23 Les types simples ................................................................... 24


char : caractre ..................................................................................... 24 int : entier standard ............................................................................... 24 short : entier court ................................................................................. 24 Page 2 sur 217

1. Les types entiers ............................................................................ 24

Module Langage de programmation structure


d) Les modificateurs signed/unsigned ........................................................... 24

2. 3.

Les types rationnels ........................................................................ 25 Exercice 1...................................................................................... 25

C.

Dclaration des variables simples ............................................. 26

1. Exercice 2...................................................................................... 26 2. Les constantes numriques .............................................................. 27


a) b) c) Les constantes entires........................................................................... 27 Les constantes rationnelles...................................................................... 28 Les caractres constants ......................................................................... 29

3. 4. 5.

Exemple 1 ..................................................................................... 29 Initialisation des variables ............................................................... 29 Exemple 2 ..................................................................................... 30

D.
a) b) c)

Les oprateurs standards ........................................................ 30


Oprateurs arithmtiques........................................................................ 31 Oprateurs logiques ............................................................................... 31 Oprateurs de comparaison ..................................................................... 31

1. Les oprateurs connus .................................................................... 31

2.
a) b)

Les oprateurs particuliers de C........................................................ 31


Les oprateurs d'affectation .................................................................... 31 Oprateurs d'incrmentation et de dcrmentation..................................... 32

E.
1. 2. 3.

Les priorits des oprateurs ..................................................... 33


Exemple 1 ..................................................................................... 35 Exemple 2 : ................................................................................... 35 Exercice 3...................................................................................... 36

F.
1. 2.

Les fonctions arithmtiques standards....................................... 36


Exemple 1 ..................................................................................... 37 Exemple 2 ..................................................................................... 38

G.
a) b) c)

Les conversions de type .......................................................... 38


Calculs et affectations............................................................................. 39 Appels de fonctions ................................................................................ 39 Rgles de conversion automatique ........................................................... 39

1. Les conversions de type automatiques .............................................. 39

2. Exercice 4...................................................................................... 40 3. Les conversions de type forces (casting) .......................................... 40

H.
1. 2. 3.

Correction des exercices .......................................................... 41


Exercice 1...................................................................................... 41 Exercice 2...................................................................................... 41 Exercice 3...................................................................................... 42
Page 3 sur 217

Module Langage de programmation structure


4. Exercice 4...................................................................................... 42

VI. Lire et crire des donnes ............................................ 43


A.
1. 2. 3. 4. 5. 6.

La fonction printf() ................................................................. 43


Exemple 1 ..................................................................................... Exemple 2 ..................................................................................... Exercice 1...................................................................................... La fonction scanf() .......................................................................... Exemple ........................................................................................ Exercice 2...................................................................................... 44 45 45 46 46 47

B.
1.

la commande putchar() ........................................................... 47


Exemple ........................................................................................ 47

C.
1. 2.

getchar() - puts(chane) et gets(chane).................................... 48


Exemple ........................................................................................ 48 Exercice 3...................................................................................... 48

D.
1. 2. 3.

Correction des exercices .......................................................... 49


Exercice1....................................................................................... 49 Exercice 2...................................................................................... 49 Exercice 3...................................................................................... 49

VII.
A.
1. 2. 3. 4. 5. 6.

Les structures Alternatives ................................... 50


La structure if else (Si Sinon) ............................................. 50
Exemple Exemple Exemple Exemple Exemple Exemple 1 ..................................................................................... 2 ..................................................................................... 3 ..................................................................................... 4 ..................................................................................... 5 ..................................................................................... 6 ..................................................................................... 50 50 51 51 51 51

B.
1.

La structure if - else if - ... - else .............................................. 52


Exemple 1 ..................................................................................... 52

C.
1.

Les oprateurs conditionnels .................................................... 53


Exemple 1 ..................................................................................... 53

D.
1. 2. 3. 4. 5.

La structure Switch - Case ....................................................... 53


Exemple 1 ..................................................................................... 54 Exercice 1...................................................................................... 54 Exercice 2...................................................................................... 54 Exercice 3...................................................................................... 55 Exercice 4...................................................................................... 55
Page 4 sur 217

Module Langage de programmation structure


E.
1. 2. 3. 4.

Correction des exercices .......................................................... 55


Exercice 1...................................................................................... Exercice 2...................................................................................... Exercice 3...................................................................................... Exercice4....................................................................................... 55 56 57 57

VIII.
A.
1.

Les structures rptitives ..................................... 58


Le structure for (Pour) ............................................................ 58
Exemple 1 ..................................................................................... 59

B.
1. 2. 3.

La structure While (tant que) ................................................... 59


Exemple 1 ..................................................................................... 59 Exemple 2 ..................................................................................... 60 Exemple 3 ..................................................................................... 60

C.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.

La structure do while (faire tant que) ..................................... 60


Exemple 1 ..................................................................................... Exemple 2 ..................................................................................... Exemple 3 ..................................................................................... Exemple 4 ..................................................................................... Exemple 5 ..................................................................................... Exercice 1...................................................................................... Exercice 2...................................................................................... Exercice 3...................................................................................... Exercice 4...................................................................................... Exercice 5 ................................................................................... Exercice 6 ................................................................................... Exercice 7 ................................................................................... Exercice 8 ................................................................................... Exercice 9 ................................................................................... Exercice Exercice Exercice Exercice Exercice Exercice Exercice Exercice Exercice 1...................................................................................... 2...................................................................................... 3...................................................................................... 4...................................................................................... 5...................................................................................... 6...................................................................................... 7...................................................................................... 8...................................................................................... 9......................................................................................
Page 5 sur 217

61 61 61 61 62 63 63 63 63 63 64 64 64 64 64 65 66 67 68 68 69 70 70

D.
1. 2. 3. 4. 5. 6. 7. 8. 9.

Correction des exercices .......................................................... 64

Module Langage de programmation structure


IX. Les structures de donnes avances ............................ 71
A. Tableaux ou vecteurs .............................................................. 71
1. Dfinition....................................................................................... 71 2. Dclaration de tableaux en C ........................................................... 71 3. Remarque...................................................................................... 72 4. Initialisation et rservation automatique ............................................ 72
a) b) c) Initialisation .......................................................................................... 72 Rservation automatique ........................................................................ 73 Exemple................................................................................................ 73

5.
a) a) b)

Accs aux composantes................................................................... 73


Exemples .............................................................................................. 74 Affectation ............................................................................................ 74

6. Affectation et affichage................................................................... 74
Affichage............................................................................................... 74

7. Exemple 1 ..................................................................................... 75 8. Exercice 1...................................................................................... 75 9. Exercice 2...................................................................................... 75 10. Exercice 3 ................................................................................... 76 11. Exercice 4 ................................................................................... 76 12. Exercice 5 ................................................................................... 76 13. Exercice 6 ................................................................................... 76 14. Exercice 7 ................................................................................... 77 15. Exercice 8 ................................................................................... 77 16. Exercice 9 ................................................................................... 78 17. Exercice 10 ................................................................................. 78

B.

Les tableaux deux dimensions ou matrices .............................. 79

1. Dfinition....................................................................................... 79 2. Exemple ........................................................................................ 80 3. Dclaration et mmorisation ............................................................ 81


a) b) Dclaration............................................................................................ 81 Mmorisation......................................................................................... 81

4.
a) b)

Initialisation et rservation automatique ............................................ 82


Initialisation .......................................................................................... 82 Rservation automatique ........................................................................ 83

5. 6.
a) b)

Accs aux composantes................................................................... 84 Affectation et affichage.................................................................... 84


Affectation ............................................................................................ 85 Affichage............................................................................................... 85 Page 6 sur 217

Module Langage de programmation structure


7. Exercice 11 .................................................................................... 85 8. Exercice 12 .................................................................................... 85 9. Exercice 13 .................................................................................... 86 10. Exercice 14 ................................................................................. 86 11. Exercice 15 ................................................................................. 86 12. Exercice 16 ................................................................................. 86 13. Exercice 17 ................................................................................. 86 14. Exercice 18 ................................................................................. 87 15. Exercice 19 ................................................................................. 87 16. Exercice 20 ................................................................................. 88 17. Exercice 21 ................................................................................. 88

C.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21.

Correction des exercices.......................................................... 89


Exercice 1...................................................................................... 89 Exercice 2...................................................................................... 90 Exercice 3...................................................................................... 90 Exercice 4...................................................................................... 91 Exercice 5...................................................................................... 92 Exercice 6...................................................................................... 94 Exercice 7...................................................................................... 94 Exercice 8...................................................................................... 95 Exercice 9...................................................................................... 98 Exercice 10 ................................................................................. 99 Exercice 11 ................................................................................101 Exercice 12 ................................................................................102 Exercice 13 ................................................................................103 Exercice 14 ................................................................................104 Exercice 15 ................................................................................104 Exercice 16 ................................................................................105 Exercice 17 ................................................................................106 Exercice 18 ................................................................................108 Exercice 19 ................................................................................110 Exercice 20 ................................................................................113 Exercice 21 ................................................................................114

X. Les chanes de caractres........................................... 115


A.
1.
a)

Introduction......................................................................... 115
Dclaration et mmorisation ...........................................................115
Dclaration...........................................................................................115 Page 7 sur 217

Module Langage de programmation structure


b) c) Espace rserv .....................................................................................115 Mmorisation........................................................................................116

2. Les chanes de caractres constantes ...............................................116 3. Initialisation de chanes de caractres ..............................................117 4. Exercice 1.....................................................................................118 5. Accs aux lments d'une chane.....................................................118 6. Prcdence alphabtique et lexicographique .....................................118
a) b) Prcdence alphabtique des caractres ..................................................118 Prcdence lexicographique des chanes de caractres...............................119

B.
a) b) c) d) e)

Travailler avec des chanes de caractres ................................ 119


Affichage de chanes de caractres ..........................................................120 Lecture de chanes de caractres ............................................................120 Exercice 2 ............................................................................................121 Exercice 3 ............................................................................................121 Exercice 4 ............................................................................................122

1. Les fonctions de <stdio.h> .............................................................120

2.
a) b) c) d)

Les fonctions de <string.h> ............................................................122


Exercice 5 ............................................................................................123 Exercice 6 ............................................................................................123 Exercice 7 ............................................................................................123 Exercice 8 ............................................................................................123

3.
a) b) c) d)

Les fonctions de <stdlib.h>.............................................................124


Conversion de Chane en Nombre............................................................124 Exercice 9 ............................................................................................124 Conversion de Nombre en Chane............................................................125 Exercice 10 ..........................................................................................125

4.
a) b)

Les fonctions de <ctype.h> ............................................................125


Les fonctions de classification .................................................................125 Les fonctions de conversion ....................................................................125

C.
a) b) c)

Tableaux de chanes de caractres.......................................... 126


Dclaration...........................................................................................126 Initialisation .........................................................................................126 Mmorisation........................................................................................126

1. Dclaration, initialisation et mmorisation.........................................126

2.
a) b) c) d) e)

Accs aux diffrentes composantes ..................................................127


Accs aux chanes .................................................................................127 Accs aux caractres .............................................................................127 Exercice 11 ..........................................................................................128 Exercice 12 ..........................................................................................128 Exercice 13 ..........................................................................................128 Page 8 sur 217

Module Langage de programmation structure


D.
1. 2. 3.

Exercices de synthse ........................................................... 128


Exercice 14 ...................................................................................128 Exercice 15 ...................................................................................128 Exercice 16 ...................................................................................129

E.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16.

Correction des exercices ........................................................ 129


Exercice 1.....................................................................................129 Exercice 2.....................................................................................130 Exercice 3.....................................................................................130 Exercice 4.....................................................................................131 Exercice 5.....................................................................................132 Exercice 6.....................................................................................132 Exercice 7.....................................................................................132 Exercice 8.....................................................................................134 Exercice 9.....................................................................................135 Exercice 10 ................................................................................135 Exercice 11 ................................................................................136 Exercice 12 ................................................................................136 Exercice 13 ................................................................................137 Exercice 14 ................................................................................137 Exercice 15 ................................................................................138 Exercice 16 ................................................................................139

XI. Les pointeurs.............................................................. 140


A.
1. 2.

Adressage de variables.......................................................... 140


Adressage direct............................................................................140 Adressage indirect .........................................................................141

B.
a) b) c)

Les pointeurs ....................................................................... 141


L'oprateur 'adresse de' : &....................................................................141 L'oprateur 'contenu de' : *....................................................................142 Dclaration d'un pointeur .......................................................................143

1. Les oprateurs de base ..................................................................141

2.
a) b)

Les oprations lmentaires sur pointeurs ........................................144


Priorit de * et &...................................................................................144 Le pointeur NUL ....................................................................................144

3.

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

C.
1.
a)

Pointeurs et tableaux ............................................................ 147


Adressage des composantes d'un tableau .........................................147
Exercice 2 ............................................................................................149 Page 9 sur 217

Module Langage de programmation structure


2. Pointeurs et chanes de caractres ...................................................149
a) b) c) d) e) Affectation ...........................................................................................149 Initialisation .........................................................................................149 Remarque ............................................................................................150 Modification..........................................................................................150 Exercice 3 ............................................................................................150

D.
1. 2. 3.

Correction des exercices ........................................................ 151


Exercice 1.....................................................................................151 Exercice 2.....................................................................................151 Exercice 3.....................................................................................152

XII.
A.
a) b) c)

Allocation dynamique de mmoire...................... 153


Dclaration statique de donnes ............................................. 153
Exemple 1 ............................................................................................153 Exemple 2 ............................................................................................153 Exemple 3 ............................................................................................154

B.
1. 2. 3.

Allocation dynamique ............................................................ 154


La fonction malooc.........................................................................154 La fonction free .............................................................................155 Exemple .......................................................................................155

C.
1.

Allocation dynamique dun tableau.......................................... 156


Exemple .......................................................................................156

XIII.
1. 2. 3. 4.

Les structures..................................................... 157


Introduction ..................................................................................157 Exemple .......................................................................................157 Exercice .......................................................................................158 Corrig .........................................................................................158

XIV.
A.
1. 2.
a)

Les fonctions ...................................................... 160


Modularisation de programmes .............................................. 160
La modularit et ses avantages .......................................................160 Exemples de modularisation en C ....................................................160
Exemple : Afficher un rectangle d'toiles..................................................160

B.
1. 2. 3.

La notion de blocs et la porte des identificateurs ..................... 162


Bloc d'instruction ...........................................................................162 Variables locales ............................................................................163 Variables globales ..........................................................................164

C.
1.

Dclaration et dfinition de fonctions ...................................... 165


Exemple 1 ....................................................................................165
Page 10 sur 217

Module Langage de programmation structure


D.
1. 2. 3. 4. 5. 6. 7. 8. 9.

Passage des paramtres dune fonction ................................... 166


Passage par valeur ........................................................................166 Passage par rfrence (Adresse) .....................................................167 Exemple .......................................................................................168 Exercice 1.....................................................................................169 Exercice 2.....................................................................................170 Exercice 3.....................................................................................170 Exercice 4.....................................................................................170 Exercice 5.....................................................................................170 Exercice 6.....................................................................................170

E.
1. 2. 3. 4. 5. 6.

Correction des exercices ........................................................ 171


Exercice Exercice Exercice Exercice Exercice Exercice 1.....................................................................................171 2.....................................................................................171 3.....................................................................................172 4.....................................................................................173 5.....................................................................................173 6.....................................................................................174

XV. Algorithmes de Tri ...................................................... 175


A. B.
1. 2. 3.

Introduction......................................................................... 175 Tri par slection ................................................................... 176


Principe ........................................................................................176 Algorithme....................................................................................176 Exemple : .....................................................................................176

C.
1. 2. 3.

Tri bulles : ........................................................................ 176


Principe ........................................................................................176 Algorithme....................................................................................177 Exemple .......................................................................................177

D. E.

Exercice rcapitulatif............................................................. 177 Correction de lexercice rcapitulatif........................................ 177

XVI.
A.

Fichiers squentiels ............................................ 179


Notion de fichier ................................................................... 179
1. Introduction ..................................................................................179 2. Dfinitions et proprits .................................................................180
a) b) Fichier .................................................................................................180 Fichier squentiel ..................................................................................180

3.

La mmoire tampon (buffer) ...........................................................180


Page 11 sur 217

Module Langage de programmation structure


4. Accs aux fichiers squentiels .........................................................181
a) b) c) Introduction .........................................................................................181 Le type FILE* .......................................................................................181 Exemple: Crer et afficher un fichier squentiel ........................................182

5.
a) b) c) d) e) f)

Ouvrir et fermer des fichiers squentiels...........................................183


Ouvrir un fichier squentiel ....................................................................183 Fermer un fichier squentiel ...................................................................184 Exemple 1 :..........................................................................................184 Exemple 2 ............................................................................................185 Exemple 3 ............................................................................................185 Exemple 4 ............................................................................................186

6.
a) b) c) d) e)

Lire et crire dans des fichiers squentiels ........................................186


Traitement par enregistrements ..............................................................187 Traitement par caractres ......................................................................190 Dtection de la fin d'un fichier squentiel .................................................191 Exercice rcapitulatif .............................................................................192 Correction ............................................................................................192

7.
a) b) c)

Mise jour d'un fichier squentiel en C ............................................194


Ajouter un enregistrement un fichier.....................................................195 Supprimer un enregistrement dans un fichier ...........................................198 Modifier un enregistrement dans un fichier ...............................................199

8. Exercice 1.....................................................................................201 9. Exercice 2.....................................................................................201 10. Exercice 3 ..................................................................................201 11. Exercice 4 ..................................................................................201 12. Exercice 5 ..................................................................................201 13. Exercice 6 ..................................................................................202 14. Exercice 7 ..................................................................................202 15. Exercice 8 ..................................................................................202 16. Exercice 9 ..................................................................................202 17. Exercice 10 ................................................................................202

B.
1. 2. 3. 4. 5. 6. 7.

Correction des exercices ........................................................ 203


Exercice Exercice Exercice Exercice Exercice Exercice Exercice 1.....................................................................................203 2.....................................................................................204 3.....................................................................................205 4.....................................................................................206 5.....................................................................................208 6.....................................................................................210 7.....................................................................................212
Page 12 sur 217

Module Langage de programmation structure


8. Exercice 8.....................................................................................213 9. Exercice 9.....................................................................................214 10. Exercice 10 ................................................................................215

Page 13 sur 217

Module Langage de programmation structure

II. Introduction programmation


A.

aux

Langages

de

Introduction
Oprations arithmtiques : addition, soustraction, multiplication Oprations de comparaisons. Lecture de valeurs et affichage de rsultats.

Lordinateur est une machine non intelligente, qui sait excuter des oprations trs simples :

Se pose alors la question trs simple : o rside limportance de lordinateur ? La rponse est quil peut tre programm : c'est--dire quon peut lui donner, lavance, la squence (suite ordonne) des instructions (ordres) effectuer lune aprs lautre. La grande puissance de lordinateur est sa rapidit. Mais, cest lhomme (programmeur) de tout faire et de tout prvoir, lordinateur ne fait quexcuter des ordres cods en binaire (langage machine). Cest pour cela que des langages dits volus ont t mis au point pour faciliter la programmation, exemples : FORTRAN, COBOL, BASIC, PASCALet bien videmment, le langage C qui favorise (tout comme le Pascal) une approche mthodique et discipline, on parle de mthode structure , ce langage a vu le jour dans les Laboratoires BELL en 1978, et il a t cre par KERNIGHAM et RITCHIE pour dvelopper le systme dexploitation UNIX.

B.

La compilation
1. Entrer le programme ou le code source dans lordinateur laide dun EDITEUR (NetBeans IDE C/C++ par exemple qui est disponible gratuitement sur Internet). 2. Traduire ce programme en langage machine (codes binaires comprhensibles par lordinateur), cest la compilation. 3. Excuter le programme et visualiser le rsultat.

Le C est un langage compil, c'est--dire quil faut passer par les tapes suivantes :

III. Premier programme en C


A. Exemple
Tous les programmes ont t crits laide de lditeur (ou plutt EDI Environnement de Dveloppement Intgr) NetBeans IDE C/C++ (ver 6.9) qui est tlchargeable gratuitement de lInternet (http://netbeans.org). Avant dinstaller NetBeans IDE C/C++ il faut tout dabord installer : 1. JDK : Netbeans est un outil conu pour le dveloppement en java, pour cela vous devez installer le JDK de Sun (Les crateur de java) cest un outil essentiel pour programmer en Java. Il permet la compilation, le dbogage et lexcution des applications Java. 2. MinGW : cest une collection doutils permettant de faire de la programmation, parmi ces outils est prsent le compilateur GCC. Page 14 sur 217

Module Langage de programmation structure


3. MSYS : MSYS a t dvelopp pour servir de support aux outils de dveloppement MinGW , il peut trs bien tre utilis comme un simple shell, sans obligation d'installer tous les tools MinGW Une fois NetBeans IDE installe sur votre ordinateur, vous pouvez lancer lapplication NetBeans IDE 6.9 partir du bouton Dmarrer, Programmes, NetBeans et enfin NetBeans IDE 6.9 pour obtenir linterface suivante :

Figure 1: Interface NetBeans 6.9 Pour crire votre premier programme en C, vous choisissez le menu File, New Project ; C/C++, C/C++ vous obtenez :

Page 15 sur 217

Module Langage de programmation structure

Figure 2: Cration d'un nouveau projet Tapez au clavier les instructions suivantes :

Page 16 sur 217

Module Langage de programmation structure

Figure 3: Premier programme en C Maintenant, vous devez Tester votre programme laide du bouton Run Main Project barre doutils et qui est aussi accessible partir du menu Run (F6) de la

Figure 4: Rsultat du programme

Page 17 sur 217

Module Langage de programmation structure

IV. Notion de base


A. La fonction main
La fonction main est la fonction principale des programmes en C: Elle se trouve obligatoirement dans tous les programmes. L'excution d'un programme entrane automatiquement l'appel de la fonction main.

1. Dfinition de la fonction main en C


|main() |{ | <dclarations> ; | <instructions> ; | return 0; |}

2. Rsultat de main
En principe tout programme devrait retourner une valeur comme code d'erreur son environnement. Par consquent, le type rsultat de main est toujours int. En gnral, le type de main n'est pas dclar explicitement, puisque c'est le type par dfaut. Nous allons terminer nos programmes par l'instruction: return 0; Qui indique l'environnement que le programme s'est termin avec succs, sans anomalies ou erreurs fatales.

3. Paramtres de main
Si la liste des paramtres de la fonction main est vide, il est d'usage de la dclarer par (). Si nous utilisons des fonctions prdfinies (par exemple: printf), il faut faire prcder la dfinition de main par les instructions #include correspondantes.

B.

Les variables

Les variables contiennent les valeurs qui sont utilises pendant l'excution du programme. Les noms des variables sont des identificateurs quelconques.

1. Les identificateurs
Page 18 sur 217

Module Langage de programmation structure


Les noms des fonctions et des variables en C sont composs d'une suite de lettres et de chiffres. Le premier caractre doit tre une lettre. Le symbole '_' est aussi considr comme une lettre. L'ensemble des symboles utilisables est donc: {0,1,2,...,9,A,B,...,Z,_,a,b,...,z} Le premier caractre doit tre une lettre (ou le symbole '_'). C distingue les majuscules et les minuscules, ainsi: 'Nom_de_variable' est diffrent de 'nom_de_variable' La longueur des identificateurs n'est pas limite, mais C distingue 'seulement' les 31 premiers caractres

a) Exemples :
Identificateurs corrects: Identificateurs incorrects: nom1 nom_2 _nom_3 Nom_de_variable deuxieme_choix mot_francais 1nom nom.2 -nom-3 Nom de variable deuxime_choix mot_franais

b) Exercice1 :
Lesquels des identificateurs suivants sont accepts par C ? fonction-1 _MOYENNE_du_MOIS_ 3e_jour limite_inf. lim_suprieure _ a 3 A_

C.Les commentaires
Un commentaire commence toujours par les deux symboles '/*' et se termine par les symboles '*/'. Il est interdit d'utiliser des commentaires imbriqus. Exemples /* Ceci est un commentaire correct */ /* Ceci est /* videmment */ dfendu */

Page 19 sur 217

Module Langage de programmation structure


D. Discussion de l'exemple 'Hello_World'

Reprenons le programme 'Hello_World' et retrouvons les particularits d'un programme en C. HELLO_WORLD en C #include <stdio.h> |main() |/* Notre premier programme en C */ |{ | printf("hello, world\n"); | return 0; |}

1. Discussion
La fonction main ne reoit pas de donnes, donc la liste des paramtres est vide. La fonction main fournit un code d'erreur numrique l'environnement, donc le type du rsultat est int et n'a pas besoin d'tre dclar explicitement. Le programme ne contient pas de variables, donc le bloc de dclarations est vide. La fonction main contient deux instructions: 1. L'appel de la fonction printf avec l'argument "hello, world\n"; Effet: Afficher la chane de caractres "hello world\n". 2. La commande return avec l'argument 0; Effet: Retourner la valeur 0 comme code d'erreur l'environnement. L'argument de la fonction printf est une chane de caractres indique entre les guillements. Une telle suite de caractres est appele chane de caractres constante (string constant). La suite de symboles '\n' la fin de la chane de caractres "hello, world\n" est la notation C pour 'passage la ligne' (angl: new line).

2. printf et la bibliothque <stdio>


La fonction printf fait partie de la bibliothque de fonctions standard <stdio> qui gre les entres et les sorties de donnes. La premire ligne du programme: #include <stdio.h> Instruit le compilateur d'inclure le fichier en-tte 'STDIO.H' dans le texte du programme. Le fichier 'STDIO.H' contient les informations ncessaires pour pouvoir utiliser les fonctions de la bibliothque standard <stdio>

a) Exercice 2
Modifiez le programme 'hello world' de faon obtenir le mme rsultat sur l'cran en utilisant plusieurs fois la fonction printf.

Page 20 sur 217

Module Langage de programmation structure

b) Exercice 3
Exprimentez avec les squences d'chappement que vous trouvez dans le tableau ci-dessous et compltez les colonnes vides. sq. d'chapp. descr. anglaise descr. franaise \n \t \" \\ \a new line passage la ligne

c) Exercice 4
Ci-dessous, vous trouvez un simple programme en C. Essayez de distinguer et de classifier autant que possible les lments qui composent ce programme (commentaires, variables, dclarations, instructions, etc.) #include <stdio.h> /* Ce programme calcule la somme de 4 nombres entiers introduits au clavier. */ main() { int NOMBRE, SOMME, COMPTEUR; /* Initialisation des variables */ SOMME = 0; COMPTEUR = 0; /* Lecture des donnes */ while (COMPTEUR < 4) { /* Lire la valeur du nombre suivant */ printf("Entrez un nombre entier :"); scanf("%i", &NOMBRE); /* Ajouter le nombre au rsultat */ SOMME += NOMBRE; /* Incrmenter le compteur */ COMPTEUR++; } /* Impression du rsultat */ printf("La somme est: %i \n", SOMME); return 0; }

Page 21 sur 217

Module Langage de programmation structure


E.Correction des exercices
1. Exercice 1
fonction-1 3e_jour limite_inf. lim_suprieure A_ _ a 3 pas accept (contient le caractre spcial '-' ) pas accept (chiffre au dbut de l'identificateur) pas accept (contient le caractre spcial '.' ) pas accept (contient le caractre spcial '' ) accept accept accept pas accept (chiffre au dbut de l'identificateur) _MOYENNE_du_MOIS_ accept

2. Exercice 2
Voici une des solutions possibles: #include <stdio.h> /* Notre premier programme en C */ main() { printf("hello, "); printf("world"); printf("\n"); return 0; }

3. Exercice 3
sq. d'chapp. descr. anglaise \n \t \" \\ \a new line tabulator back-slash attention (bell) descr. franaise passage la ligne tabulation trait oblique signal acoustique

quotation marks guillemets

Page 22 sur 217

Module Langage de programmation structure


4. Exercice 4
Commande au compilateur: #include<stdio.h> : pour pouvoir utiliser les fonctions printf et scanf. Fonction main : n'a pas de paramtres (la liste des paramtres est vide) et fournit par dfaut un rsultat du type int ( l'environnement). Commentaires (mis en italique). Variables utilises: NOMBRE, SOMME, COMPTEUR dclares comme entiers (type int). Fonctions utilises: printf, scanf de la bibliothque <stdio>. Oprateurs: += oprateur arithmtique d'affectation ++ oprateur arithmtique < = oprateur de comparaison oprateur d'affectation

Structure de contrle: while(<condition>) { ... } : rpte le bloc d'instructions aussi longtemps que la <condition> est remplie. L'instruction return 0; :retourne la valeur zro comme code d'erreur l'environnement aprs l'excution du programme La fonction scanf est appele avec deux paramtres: le format de saisie de la donne (ici: "%i" pour lire un entier du type int) l'adresse de la variable destination (ici: l'adresse de NOMBRE). La fonction printf est appele avec un respectivement avec deux paramtres: le premier paramtre est une chane de caractres, qui peut contenir une information pour le format d'affichage des variables indiques dans la suite (ici: "%i" pour afficher la valeur du type int contenue dans SOMME). Les paramtres qui suivent la chane de caractres indiquent les noms des variables afficher. (ici: SOMME)

V. Types de expressions
A. Introduction

base,

oprateurs

et

Les variables et les constantes sont les donnes principales qui peuvent tre manipules par un programme. Les dclarations introduisent les variables qui sont utilises, fixent leur type et parfois aussi leur valeur de dpart. Les oprateurs contrlent les actions que subissent les valeurs des donnes. Pour produire de nouvelles valeurs, les variables et les constantes peuvent tre combines l'aide des oprateurs dans des expressions. Le type d'une donne dtermine l'ensemble des valeurs admissibles, le nombre d'octets rserver en mmoire et l'ensemble des oprateurs qui peuvent y tre appliqus.

Page 23 sur 217

Module Langage de programmation structure


B. Les types simples

1. Les types entiers


Avant de pouvoir utiliser une variable, nous devons nous intresser deux caractristiques de son type numrique: 1. Le domaine des valeurs admissibles 2. Le nombre d'octets qui est rserv pour une variable Le tableau suivant rsume les caractristiques des types numriques entiers de C : dfinition description char short int long caractre entier court entier long domaine min domaine max nombre d'octets -128 -32768 127 32767 32767 1 2 2

entier standard -32768

-2147483648 2147483647 4

a) char : caractre
Une variable du type char peut contenir une valeur entre -128 et 127 et elle peut subir les mmes oprations que les variables du type short, int ou long.

b) int : entier standard


Sur chaque machine, le type int est le type de base pour les calculs avec les entiers. Le codage des variables du type int est donc dpendant de la machine. Sur les IBM-PC sous MSDOS, une variable du type int est code dans deux octets.

c) short : entier court


Le type short est en gnral cod dans 2 octets. Comme une variable int occupe aussi 2 octets sur notre systme, le type short devient seulement ncessaire, si on veut utiliser le mme programme sur d'autres machines, sur lesquelles le type standard des entiers n'est pas forcment 2 octets.

d) Les modificateurs signed/unsigned


Si on ajoute le prfixe unsigned la dfinition d'un type de variables entires, les domaines des variables sont dplacs comme suit: dfinition description domaine min domaine max nombre d'octets 0 0 0 255 65535 65535 1 2 2

unsigned char caractre unsigned short entier court unsigned int unsigned long entier long

entier standard 0

4294967295 4

Page 24 sur 217

Module Langage de programmation structure

En principe, on peut dire que : sizeof(short) <= sizeof(int) <= sizeof(long) Ainsi sur certaine architecture on peut avoir short = 2 octets, int = 2 octets, long = 4 octets Et sur d'autre : short = 2 octets, int = 4 octets, long = 4 octets

2. Les types rationnels


En informatique, les rationnels sont souvent appels des 'flottants'. Ce terme vient de 'en virgule flottante' et trouve sa racine dans la notation traditionnelle des rationnels: <+|-> <mantisse> * 10<exposant> <+|-> est le signe positif ou ngatif du nombre <mantisse> est un dcimal positif avec un seul chiffre devant la virgule. <exposant> est un entier relatif En C, nous avons le choix entre trois types de rationnels: float, double et long double. Dans le tableau ci-dessous, vous trouverez leurs caractristiques: Min et max : reprsentent les valeurs minimales et maximales positives. Les valeurs ngatives peuvent varier dans les mmes domaines. Mantisse : indique le nombre de chiffres significatifs de la mantisse. mantisse domaine min domaine max 6 15 3.4 * 10 1.7 * 10 3.4 * 10
-38 -308 -4932

dfinition float double

nombre d'octets 4 8 10

3.4 * 10 1.7 * 10 1.1 * 10

38 308 4932

long double 19

3. Exercice 1
Quel(s) type(s) numrique(s) pouvez-vous utiliser pour les groupes de nombres suivants? Dressez un tableau et marquez le choix le plus conomique: (1) 1 12 4 0 -125 (2) 1 12 -4 0 250 (3) 1 12 4 0 250 (4) 1 12 -4 0.5 125 (5) -220 32000 0 (6) -3000005.000000001 (7) 410 50000 2 (8) 410 50000 -2 (9) 3.14159265 1015 (10) 2*107 10000001 Page 25 sur 217

Module Langage de programmation structure


(11) 2*10-7 10000001 (12) -1.05*1050 0.0001 (13) 305.122212 0 -12

C.Dclaration des variables simples


Maintenant que nous connaissons les principaux types de variables, il nous faut encore la syntaxe pour leur dclaration: Pour dclarer une variable en C : <Type> <NomVar1>,<NomVar2>,...,<NomVarN>; Exemple : int compteur,X,Y; float hauteur,largeur; double masse_atomique; char touche; int t_pressee; La syntaxe des dclarations en C ressemble celle du langage algorithmique. Remarquez quand mme les points-virgules la fin des dclarations en C. entier : Nous avons le choix entre tous les types entiers (inclusivement char) dans leurs formes signed ou unsigned. Si les nombres deviennent trop grands pour unsigned long, il faut utiliser un type rationnel (p.ex: double) rel : Nous pouvons choisir entre les trois types rationnels en observant non seulement la grandeur maximale de l'exposant, mais plus encore le nombre de chiffres significatifs de la mantisse. caractre : Toute variable du type char peut contenir un (seul) caractre. En C, il faut toujours tre conscient que ce 'caractre' n'est autre chose qu'un nombre correspondant un code (ici: code ASCII). Ce nombre peut tre intgr dans toute sorte d'oprations algbriques ou logiques ... chane : En C il n'existe pas de type spcial pour chanes de caractres. Les moyens de traiter les chanes de caractres seront dcrits au chapitre rserv aux chanes de caractres. boolen : En C il n'existe pas de type spcial pour variables boolennes. Tous les types de variables numriques peuvent tre utiliss pour exprimer des oprations logiques:

1. Exercice 2
Traduisez les dclarations suivantes en C, sachant que vous travaillerez dans les ensembles de nombres indiqus. Choisissez les types les plus conomiques, sans perdre en prcision. (1) entier COMPTEUR {0 ,..., 300} (2) entier X,Y {-120 ,..., 100} Page 26 sur 217

Module Langage de programmation structure


(3) (4) (5) (6) (7) (8) (9) entier rel rel entier entier entier entier MESURE {-10 ,..., 104}

SURFACE1 {0.5 ,..., 150075} SURFACE2 {-12 ,..., 1500750.5} N1 N2 N3 N4 {0 ,..., 210} {-47 ,..., 47} {0 ,..., 326} {-1280 ,..., 1285} {vrai, faux}

(10) boolen TROUVE

2. Les constantes numriques


En pratique, nous utilisons souvent des valeurs constantes pour calculer, pour initialiser des variables, pour les comparer aux variables, etc. Dans ces cas, l'ordinateur doit attribuer un type numrique aux valeurs constantes. Pour pouvoir prvoir le rsultat et le type exact des calculs, il est important pour le programmeur de connatre les rgles selon lesquelles l'ordinateur choisit les types pour les constantes.

a) Les constantes entires (a) Type automatique


Lors de l'attribution d'un type une constante entire, C choisit en gnral la solution la plus conomique: Le type des constantes entires Si possible, les constantes entires obtiennent le type int. Si le nombre est trop grand pour int (p.ex: -40000 ou +40000) il aura automatiquement le type long. Si le nombre est trop grand pour long, il aura le type unsigned long. Si le nombre est trop grand pour unsigned long, la raction du programme est imprvisible.

(b)

Type forc

Si nous voulons forcer l'ordinateur utiliser un type de notre choix, nous pouvons employer les suffixes suivants: suffixe u ou U l ou L type long Exemple 123456789L 12092UL

unsigned (int ou long) 550u

ul ou UL unsigned long Exemples : 12345 type int 52000 -2 type long type int

Page 27 sur 217

Module Langage de programmation structure


0 1u 22LU type int type unsigned int Erreur !

52000u type unsigned long

(c)

Base octale et hexadcimale

Il est possible de dclarer des constantes entires en utilisant la base octale ou hexadcimale: Si une constante entire commence par 0 (zro), alors elle est interprte en base octale. Si une constante entire commence par 0x ou 0X , alors elle est interprte en base hexadcimale Exemple : base dcimale base octale base hexadcimale reprs. binaire 100 255 65536 12 4040 0144 0377 0200000 014 07710 0X64 0xff 0X10000 0XC 0xFC8 1100100 11111111 10000000000000000 1100 111111001000

b) Les constantes rationnelles


Les constantes rationnelles peuvent tre indiques: En notation dcimale, c.--d. l'aide d'un point dcimal: Exemples 123.4 -0.001 1.0

En notation exponentielle, c.--d. l'aide d'un exposant spar du nombre dcimal par les caractres 'e' ou 'E':

Exemples 1234e-1 -1E-3 0.01E2 L'ordinateur reconnat les constantes rationnelles au point dcimal ou au sparateur de l'exposant ('e' ou 'E'). Par dfaut, les constantes rationnelles sont du type double

(d)

Le type des constantes rationnelles


Sans suffixe, les constantes rationnelles sont du type double. Le suffixe f ou F force l'utilisation du type float. Le suffixe l ou L force l'utilisation du type long double

Page 28 sur 217

Module Langage de programmation structure


c) Les caractres constants
Les constantes qui dsignent un (seul) caractre sont toujours indiques entre des apostrophes: par exemple 'x'. La valeur d'un caractre constant est le code interne de ce caractre. Ce code (ici: le code ASCII) est dpendant de la machine. Les caractres constants peuvent apparatre dans des oprations arithmtiques ou logiques, mais en gnral ils sont utiliss pour tre compars des variables. La constante '\0' qui a la valeur numrique zro (ne pas confondre avec le caractre '0' !!) a une signification spciale dans le traitement et la mmorisation des chanes de caractres: En C le caractre '\0' dfinit la fin d'une chane de caractres.

3. Exemple 1
Exemple : #define PI 3.14 ou const float pi=3.14 #include <stdio.h> #include <stdlib.h> #define PI 3.14 /* PI est une constante=3,14 */ // on peut aussi utiliser : const float PI=3.14; int main () { float P,R; printf("Entrez la valeur du rayon : "); scanf("%f", &R); P=2*PI*R; printf("Le perimetre du cerle est : %f\n",P); printf("Fin du travail\n"); return 0; }

4. Initialisation des variables


En C, il est possible d'initialiser les variables lors de leur dclaration: int MAX = 1023; char TAB = '\t'; float X = 1.05e-4; const int MAX = 767; const double e = 2.71828182845905; const char NEWLINE = '\n'; Page 29 sur 217

Module Langage de programmation structure


5. Exemple 2
Dclaration de type : De nouveaux types de variables peuvent tre dclars laide de typedef. Cela permet de donner un nom un type donn, mais ne cre aucune variable.

#include <stdio.h> #include <stdlib.h> int main () { typedef float prix; typedef float quantite; typedef float total; prix a, b; quantite x, y; total z, t; printf("Entrez les prix a et b : "); scanf("%f %f", &a, &b); printf("Entrez les quantites x et y : "); scanf("%f %f", &x, &y); z = a * x; t= b * y; printf("Le total1 est : %f et Le total2 est : %f\n", z, t); printf("Fin du travail\n"); return 0; }

D.

Les oprateurs standards

Affectation en C <NomVariable> = <Expression>; Exemples d'affectations : L'affectation avec des valeurs constantes LONG = 141; PI = 3.1415926; NATION = 'L'; L'affectation avec des valeurs de variables VALEUR = XA; LETTRE = COURRIER; L'affectation avec des valeurs d'expressions AIRE = PI*pow(R,2); MOYENNE = (A+B)/2; UN=pow(sin(X),2)+pow(cos(X),2); Page 30 sur 217

Module Langage de programmation structure


RES = 45+5*X; PLUSGRAND = (X>Y); CORRECT = ('a' == 'a');

1. Les oprateurs connus


a) Oprateurs arithmtiques
+ addition * / soustraction multiplication division (entire et rationnelle!)

% modulo (reste d'une div. entire)

b) Oprateurs logiques
&& et logique (and) || ! ou logique (or) ngation logique (not)

c) Oprateurs de comparaison
== != gal diffrent de

<, <=, >, >= plus petit que, ... Remarque : Les rsultats des oprations de comparaison et des oprateurs logiques sont du type int: La valeur 1 correspond la valeur boolenne vrai La valeur 0 correspond la valeur boolenne faux Les oprateurs logiques considrent toute valeur diffrente de zro comme vrai et zro comme faux Exemple : 32 && 2.3 !65.34 0||!(32 > 12) 0

1 0

2. Les oprateurs particuliers de C


a) Les oprateurs d'affectation
En pratique, nous retrouvons souvent des affectations comme: Page 31 sur 217

Module Langage de programmation structure


i=i+2 En C, nous utiliserons plutt la formulation plus compacte: i += 2 L'oprateur += est un oprateur d'affectation. Pour la plupart des expressions de la forme: expr1 = (expr1) op (expr2) Il existe une formulation quivalente qui utilise un oprateur d'affectation: expr1 op= expr2 Oprateurs d'affectation : += ajouter -= *= /= diminuer de multiplier par diviser par

%= modulo Les oprateurs d'affectation deviennent le plus intressant si expr1 est une expression complexe. Ceci peut tre le cas si nous calculons avec des tableaux. L'expression: Element[n*i+j] = Element[n*i+j] * x[j] Peut tre formule de manire plus efficiente et plus claire: Element[n*i+j] *= x[j]

b) Oprateurs d'incrmentation et de dcrmentation


Les affectations les plus frquentes sont du type: I=I+1 et I=I-1 En C, nous disposons de deux oprateurs inhabituels pour ces affectations: I++ ou ++I pour l'incrmentation I-- ou --I (augmentation d'une unit)

pour la dcrmentation (diminution d'une unit)

Les oprateurs ++ et -- sont employs dans les cas suivants: Incrmenter/dcrmenter une variable (p.ex: dans une boucle). Dans ce cas il n'y a pas de diffrence entre la notation prfixe (++I --I) et la notation postfixe (I++ I--). Incrmenter/dcrmenter une variable et en mme temps affecter sa valeur une autre variable. Dans ce cas, nous devons choisir entre la notation prfixe et postfixe: X = I++ passe d'abord la valeur de I X et incrmente aprs X = I-passe d'abord la valeur de I X et dcrmente aprs X = ++I incrmente d'abord et passe la valeur incrmente X X = --I dcrmente d'abord et passe la valeur dcrmente X Exemple : Supposons que la valeur de N est gal 5: Incrm. postfixe: X = N++; Rsultat: N=6 et X=5 Page 32 sur 217

Module Langage de programmation structure


Incrm. prfixe: X = ++N; Rsultat: N=6 et X=6

E.Les priorits des oprateurs


L'ordre de l'valuation des diffrentes parties d'une expression correspond en principe celle que nous connaissons des mathmatiques. Exemple Supposons pour l'instruction suivante: A=5, B=10, C=1 X = 2*A+3*B+4*C; L'ordinateur value d'abord les multiplications: 2*A ==> 10 , 3*B ==> 30 , 4*C ==> 4 Ensuite, il fait l'addition des trois rsultats obtenus: 10+30+4 ==> 44 A la fin, il affecte le rsultat gnral la variable: X = 44 Priorit d'un oprateur : On dit alors que la multiplication a la priorit sur l'addition et que la multiplication et l'addition ont la priorit sur l'affectation. Si nous voulons forcer l'ordinateur commencer par un oprateur avec une priorit plus faible, nous devons (comme en mathmatiques) entourer le terme en question par des parenthses. Exemple Dans l'instruction: X = 2*(A+3)*B+4*C; L'ordinateur value d'abord l'expression entre parenthses, ensuite les multiplications, ensuite l'addition et enfin l'affectation. (En reprenant les valeurs de l'exemple ci-dessus, le rsultat sera 164). Entre les oprateurs que nous connaissons jusqu'ici, nous pouvons distinguer les classes de priorits suivantes: Priorit 1 (la plus forte): Priorit 2: Priorit 3: Priorit 4: Priorit 5: Priorit 6: Priorit 7: Priorit 8: () ! ++ -*/% +< <= > >= == != && ||

Priorit 9 (la plus faible): = += -= *= /= %=

Evaluation d'oprateurs de la mme classe : Page 33 sur 217

Module Langage de programmation structure


Dans chaque classe de priorit, les oprateurs ont la mme priorit. Si nous avons une suite d'oprateurs binaires de la mme classe, l'valuation se fait en passant de la gauche vers la droite dans l'expression. Pour les oprateurs unaires (!,++,--) et pour les oprateurs d'affectation (=,+=,=,*=,/=,%=), l'valuation se fait de droite gauche dans l'expression.

Exemple : l'expression 10+20+30-40+50-60 sera value comme suit: 10+20 ==> 30 30+30 ==> 60 60-40 ==> 20 20+50 ==> 70 70-60 ==> 10 Pour A=3 et B=4, l'expression A *= B += 5 sera value comme suit:

Pour A=1 et B=4, l'expression !--A==++!B sera value comme suit:

Les parenthses : Les parenthses sont seulement ncessaires si nous devons forcer la priorit, mais elles sont aussi permises si elles ne changent rien la priorit. En cas de parenthses imbriques, l'valuation se fait de l'intrieur vers l'extrieur. Exemple :en supposant nouveau que A=5, B=10, C=1 l'expression suivante s'valuera 134: X = ((2*A+3)*B+4)*C Observez la priorit des oprateurs d'affectation : Page 34 sur 217

Module Langage de programmation structure


X *= Y + 1 X *= Y + 1 <=> n'quivaut PAS X = X * (Y + 1) X=X*Y+1

1. Exemple 1
#include <stdio.h> #include <stdlib.h> int main () { int i; i=4; i+=1; printf("i = %d\n",i); i-=1; printf("i = %d\n",i); i*=2; printf("i = %d\n",i); i++; // trs utile dans les boucles for printf("i = %d\n",i); i--; printf("i = %d\n",i); printf("Fin du travail\n"); return 0; }

2. Exemple 2 :
Rsolution de lquation du 1er degr : ax + b = 0 #include <stdio.h> #include <stdlib.h> int main () { float a, b, x; printf("Entrez les valeurs de a et b : "); scanf("%f %f",&a,&b); if (a!= 0) { x=-b/a; printf("le resultat est : %f\n",x); } else if (b==0) printf("Tout reel est solution\n"); else printf("Pas de solution\n"); Page 35 sur 217

Module Langage de programmation structure


printf("Fin du travail\n"); return 0;

3. Exercice 3
Evaluer les expressions suivantes en supposant A=20 B=5 C=-10 D=2 X=12 Y=15 Notez chaque fois la valeur rendue comme rsultat de l'expression et les valeurs des variables dont le contenu a chang. (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (5*X)+2*((3*B)+4) (5*(X+2)*3)*(B+4) A == (B=5) A += (X+5) A != (C *= (-D)) A *= C+(X-D) A %= D++ A %= ++D (X++)*(A+C) A = X*(B<C)+Y*!(B<C) !(X-D+C)||D A&&B||!0&&C&&!D ((A&&B)||(!0&&C))&&!D ((A&&B)||!0)&&(C&&(!D))

F. Les fonctions arithmtiques standards


Les fonctions suivantes sont prdfinies dans la bibliothque standard <math>. Pour pouvoir les utiliser, le programme doit contenir la ligne: #include <math.h> Type des donnes Page 36 sur 217

Module Langage de programmation structure


Les arguments et les rsultats des fonctions arithmtiques sont du type double. Fonctions arithmtiques COMMANDE C EXPLICATION exp(X) log(X) log10(X) pow(X,Y) sqrt(X) fabs(X) floor(X) ceil(X) fmod(X,Y) fonction exponentielle logarithme naturel logarithme base 10 X exposant Y racine carre de X valeur absolue de X Arrondir en moins Arrondir en plus reste rationnel de X/Y (mme signe que X) pour X diffrent de 0 sinus, cosinus, tangente de X LANG. ALGORITHMIQUE eX ln(X), X>0 log10(X), X>0 XY pour X>0 |X|

sin(X) cos(X) tan(X)

asin(X) acos(X) atan(X) arcsin(X), arccos(X), arctan(X)

1. Exemple 1
Tapez le programme suivant : #include <stdio.h> #include <stdlib.h> #include <math.h> int main () { double A, B, RES; /* Saisie de A et B */ printf("Introduire la valeur pour A : "); scanf("%lf", &A); printf("Introduire la valeur pour B : "); scanf("%lf", &B); RES = A*A; /* Affichage du rsultat */ printf("Le carr de A est %f \n", RES); /* Calcul */ RES = B*B; /* Affichage du rsultat */ printf("Le carr de B est %f \n", RES); printf("Fin du travail\n"); system("pause"); return 0; }

Page 37 sur 217

Module Langage de programmation structure

2. Exemple 2
Modifiez le programme prcdent de faon ce qu'il affiche : - AB (A la puissance B), - L'hypotnuse d'un triangle rectangle de cts A et B, - La tangente de A en n'utilisant que les fonctions sin et cos, - La valeur arrondie (en moins) de A/B, - La valeur arrondie (en moins) trois positions derrire la virgule de A/B. #include <stdio.h> #include <stdlib.h> #include <math.h> int main () { double A, B, RES; printf("Introduire les valeurs de A et B : "); scanf("%lf %lf", &A, &B); RES = pow(A,B); printf("A exposant B est %e \n", RES); // pour l'affichage decimal : %f RES = sqrt(pow(A,2)+pow(B,2)); printf("hypotenuse du triangle rectangle est %f \n", RES); RES = sin(A)/cos(A); printf("La tangente de A est %f \n", RES); RES = floor(A/B); printf("La valeur arrondie en moins de A/B est %f \n", RES); printf("Fin du travail\n"); system("pause"); return 0; }

G.

Les conversions de type

La grande souplesse du langage C permet de mlanger des donnes de diffrents types dans une expression. Avant de pouvoir calculer, les donnes doivent tre converties dans un mme type. La plupart de ces conversions se passent automatiquement, sans l'intervention du programmeur, qui doit quand mme prvoir leur effet. Parfois il est ncessaire de convertir Page 38 sur 217

Module Langage de programmation structure


une donne dans un type diffrent de celui que choisirait la conversion automatique; dans ce cas, nous devons forcer la conversion l'aide d'un oprateur spcial ("cast").

1. Les conversions de type automatiques


a) Calculs et affectations
Si un oprateur a des oprandes de diffrents types, les valeurs des oprandes sont converties automatiquement dans un type commun. Ces manipulations implicites convertissent en gnral des types plus 'petits' en des types plus 'larges'; de cette faon on ne perd pas en prcision. Exemple : Considrons le calcul suivant: int I = 8; float X = 12.5; double Y; Y = I * X; Pour pouvoir tre multipli avec X, la valeur de I est convertie en float (le type le plus large des deux). Le rsultat de la multiplication est du type float, mais avant d'tre affect a Y, il est converti en double. Nous obtenons comme rsultat:

Y = 100.00

b) Appels de fonctions
Lors de l'appel d'une fonction, les paramtres sont automatiquement convertis dans les types dclars dans la dfinition de la fonction. Exemple : Au cours des expressions suivantes, nous assistons trois conversions automatiques: int A = 200; int RES; RES = pow(A, 2); A l'appel de la fonction pow, la valeur de A et la constante 2 sont converties en double, parce que pow est dfinie pour des donnes de ce type. Le rsultat (type double) retourn par pow doit tre converti en int avant d'tre affect RES.

c) Rgles de conversion automatique


Conversions automatiques lors d'une opration avec : Deux entiers: D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur choisit le plus large des deux types dans l'chelle suivante: int, unsigned int, long, unsigned long Un entier et un rationnel: Le type entier est converti dans le type du rationnel. Deux rationnels: L'ordinateur choisit le plus large des deux types selon l'chelle suivante: Page 39 sur 217

Module Langage de programmation structure


float, double, long double Affectations et oprateurs d'affectation: Lors d'une affectation, le rsultat est toujours converti dans le type de la destination. Si ce type est plus faible, il peut y avoir une perte de prcision. Exemple Observons les conversions ncessaires lors d'une simple division: int X; float A=12.48; char B=4; X=A/B; B est converti en float. Le rsultat de la division est du type float et sera converti en int avant d'tre affect X, ce qui conduit au rsultat X=3 .

2. Exercice 4
Soient les dclarations: long A = 15; char B = 'A'; /* code ASCII : 65 */ short C = 10; Quels sont le type et la valeur de chacune des expressions: (1) (2) (3) (4) (5) (6) C + 3 B + 1 C+B 3*C+2*B 2 * B + (A + 10) / C 2 * B + (A + 10.0) / C

3. Les conversions de type forces (casting)


Il est possible de convertir explicitement une valeur en un type quelconque en forant la transformation l'aide de la syntaxe: (<Type>) <Expression> Exemple Nous divisons deux variables du type entier. Pour avoir plus de prcision, nous voulons avoir un rsultat de type rationnel. Pour ce faire, nous convertissons l'une des deux oprandes en float. Automatiquement C convertira l'autre oprande en float et effectuera une division rationnelle: char A=3; int B=4; float C; C = (float)A/B; La valeur de A est explicitement convertie en float. La valeur de B est automatiquement convertie en float (rgle 2). Le rsultat de la division (type rationnel, valeur 0.75) est affect C. Page 40 sur 217

Module Langage de programmation structure


Rsultat: C=0.75 Attention ! Les contenus de A et de B restent inchangs; seulement les valeurs utilises dans les calculs sont converties !

H.

Correction des exercices

1. Exercice 1
signed No: char 1 2 3 4 5 6 7 8 9 10 11 12 13 X choix possible !X! meilleur choix !X! X X !X! !X! !X! X X X X X !X! X !X! !X! !X! !X! !X! X !X! X !X! X X X X X !X! X X X unsigned short int long char !X! X short int long float double long double X X X !X! X X X X X X X X X X X !X! X X X X X X X

2. Exercice 2
1) (2) (3) (4) (5) entier COMPTEUR {0 ,..., 300} int COMPTEUR; entier X,Y char X,Y; entier MESURE int MESURE; rel SURFACE1 float SURFACE1; rel SURFACE2 {0.5 ,..., 150075} 6 positions significatives {-12 ,..., 1500750.5} Page 41 sur 217 {-10 ,..., 104} {-120 ,..., 100}

Module Langage de programmation structure


double SURFACE2; 8 positions significatives (6) (7) (8) (9) entier N1 int N1; entier N2 int N2; entier N3 long N3; entier N4 double N4; (10) boolen TROUVE int TROUVE; {-1280 ,..., 1285} = {-1 ,..., 3.4*1010} 11 positions significatives {vrai, faux} par convention {0 ,..., 326} = {0 ,..., 1 073 741 824} {-47 ,..., 47} = {-16384 ,..., 16384} {0 ,..., 210} = {0 ,..., 1024}

3. Exercice 3
Evaluer les expressions suivantes en supposant A=20 B=5 C=-10 D=2 X=12 Y=15

(1) (2) (3) (4) (5) (6) (7) (8) (9)

(5*X)+2*((3*B)+4) (5*(X+2)*3)*(B+4) A == (B=5) A += (X+5) A != (C *= (-D)) A *= C+(X-D) A %= D++ A %= ++D (X++)*(A+C)

-> 98 -> 1890 -> 0 -> 37 -> 0 -> 0 -> 0 -> 2 -> 120 -> 0+15 = 15 -> !0||1 = 1 -> 1||1&&1&&0 = 1 -> (1||1)&&0 = 0

/ / B=5 A=37 C=20 A=0 D=3 A=0 D=3 A=2 X=13 A=15 / / /

(10) A = X*(B<C)+Y*!(B<C) (11) !(X-D+C)||D (12) A&&B||!0&&C&&!D (13) ((A&&B)||(!0&&C))&&!D

(14) ((A&&B)||!0)&&(C&&(!D)) -> (1||1)&&(1&&0) = 0 /

4. Exercice 4
Soient les dclarations: long A = 15; char B = 'A'; short C = 10; /* code ASCII : 65 */ Page 42 sur 217

Module Langage de programmation structure

Expression (1) C + 3 (2) B + 1 (3) C + B (4) 3 * C + 2 * B (5) 2 * B + (A + 10) / C

Type int int int int long

Valeur 13 66 75 160 132

(6) 2 * B + (A + 10.0) / C double 132.5

VI. Lire et crire des donnes


La bibliothque standard <stdio> contient un ensemble de fonctions qui assurent la communication de la machine avec le monde extrieur.

A.

La fonction printf()

La fonction printf est utilise pour afficher ou transfrer du texte, ou des valeurs de variables vers le fichier de sortie standard stdout (par dfaut l'cran). La syntaxe de la fonction printf est la suivante : printf("<format>",<Expr1>,<Expr2>, ... ); <Format> : format de reprsentation <Expr1> : variables et expressions dont les valeurs sont reprsenter Soit la suite d'instructions: int A = 1234; int B = 567; printf("%i fois %i est %li\n", A, B, (long)A*B); Cette suite va afficher sur l'cran: 1234 fois 567 est 699678 Les arguments de printf sont - la partie format "%i fois %i est %li" - la variable - la variable - l'expression
er

A B (long)A*B ==>1234 ==> 567

Le 1 spcificateur (%i) indique que la valeur de A sera imprime comme entier relatif Le 2e spcificateur (%i) indique que la valeur de B sera imprime comme entier relatif Le 3e spcificateur (%li) indique que la valeur de ==> 699678 (long)A*B sera imprime comme entier relatif long Page 43 sur 217

Module Langage de programmation structure

La suite d'instructions: char B = 'A'; printf("Le caractre %c a le code %i !\n", B, B); Va afficher sur l'cran: Le caractre A a le code 65 ! La valeur de B est donc affiche sous deux formats diffrents: %c comme caractre: %i A

comme entier relatif: 65


TYPE IMPRESSION COMME

En Rsum, voici les spcificateurs de format de printf :


SYMBOLE

%d ou %i int %u %o %x %c %f %e %s int int int int

entier relatif entier naturel (unsigned) entier exprim en octal entier exprim en hexadcimal caractre

double rationnel en notation dcimale double rationnel en notation scientifique char* chane de caractres

1. Exemple 1
Ecrivez la suite d'instructions dans un fichier source exemple1 : #include <stdio.h> #include <stdlib.h> int main () { int a = 2; int b = 4; printf("%d fois %d est %d\n", a, b, a*b); printf("Fin du travail\n"); return 0; }

Page 44 sur 217

Module Langage de programmation structure


2. Exemple 2
Taper dans un fichier source exemple2 le code ci-dessous, constatez que les numros de lignes ont t affichs ! (Outils, Options de lEditeur et Affichage) : #include <stdio.h> #include <stdlib.h> int main () { float x = 10.1234; double y = 20.1234567; printf("%f\n", x); printf("%f\n", y); printf("%e\n", x); printf("%e\n", y); printf("Fin du travail\n"); return 0; }

3. Exercice 1
#include <stdio.h> main() { int N=10, P=5, Q=10, R; char C='S'; N = 5; P = 2; Q = N++ > P || P++ != 3; printf ("C : N=%d P=%d Q=%d\n", N, P, Q); N = 5; P = 2; Q = N++ < P || P++ != 3; printf ("D : N=%d P=%d Q=%d\n", N, P, Q); N = 5; P = 2; Q = ++N == 3 && ++P == 3; printf ("E : N=%d P=%d Q=%d\n", N, P, Q); N=5; P=2; Q = ++N == 6 && ++P == 3; printf ("F : N=%d P=%d Q=%d\n", N, P, Q); Page 45 sur 217

Module Langage de programmation structure


N=C; printf ("G : %c %c\n", C, N); printf ("H : %d %d\n", C, N); printf ("I : %x %x\n", C, N); return 0;

} a) Sans utiliser l'ordinateur, trouvez et notez les rsultats du programme ci-dessus. b) Vrifiez vos rsultats l'aide de l'ordinateur.

4. La fonction scanf()
La fonction scanf est la fonction symtrique printf, mais au lieu dafficher, elle permet de lire des variables; elle fonctionne pratiquement comme printf, mais en sens inverse. Cette fonction reoit des donnes partir du fichier dentre standard stdin (le clavier par dfaut), ces donnes sont mmorises aux adresses indiques par &. La syntaxe de la fonction scanf() est la suivante : scanf("<format>",<AdrVar1>,<AdrVar2>, ...) ;

<Format> : format de lecture des donnes <AdrVar1> : adresses des variables auxquelles les donnes seront attribues

Soit la suite d'instructions: int JOUR, MOIS, ANNEE; scanf("%i %i %i", &JOUR, &MOIS, &ANNEE); cette suite dinstruction lit trois entiers relatifs, spars par des espaces, tabulations ou interlignes. Les valeurs sont attribues respectivement aux trois variables JOUR, MOIS et ANNEE.

5. Exemple
#include <stdio.h> #include <stdlib.h> int main () { int jour, mois, annee; scanf("%d %d %d", &jour, &mois, &annee); printf("le jour est: %d le mois est: %d l'annee est: %d\n", jour, mois, annee); printf("Fin du travail\n"); return 0; } A lexcution :

Page 46 sur 217

Module Langage de programmation structure


Remarque: scanf retourne comme rsultat le nombre de donnes correctement reues (type int).

6. Exercice 2
Ecrivez un programme qui lit la date du clavier et crit les donnes ainsi que le nombre de donnes correctement reues sur l'cran. Exemple: Introduisez la date (jour mois anne): 11 11 1991 donnes reues : 3 jour : 11 mois : 11 anne : 1991

B.

la commande putchar()

La commande putchar ('a') affiche le caractre a lcran (stdout), largument de cette fonction est bien videmment un caractre.

1. Exemple
#include <stdio.h> #include <stdlib.h> int main () { char a = 225; char b = 'e'; putchar('x'); /* afficher la lettre x */ putchar('\n'); /* retour la ligne */ putchar('?'); /* afficher le symbole ? */ putchar('\n'); /* retour la ligne */ putchar(65); /* afficher le symbole avec */ /* le code 65 (ASCII: 'A') */ putchar('\n'); putchar(a); /* afficher la lettre avec */ /* le code 225 (ASCII: '') */ putchar('\n'); putchar(b); /* affiche le contenu de la var b 'e' */ putchar('\n'); printf("\nFin du travail\n"); /* 2 retours la ligne! */ return 0; }

Page 47 sur 217

Module Langage de programmation structure

C.getchar() - puts(chane) et gets(chane)


La fonction getchar, plus utilise que putchar, permet de lire le prochain caractre du fichier dentre standard stdin. La fonction puts(chane) affiche, lcran, la chane de caractres chane puis positionne le curseur en dbut de ligne suivante. La fonction gets(chane) lecture d'une chane sur stdin. Tous les caractres peuvent tre entrs, y compris les blancs. La saisie est termine par un retour chariot.

1. Exemple
#include <stdio.h> #include <stdlib.h> int main () { char a ; char TEXTE[] = "Voici une premiere ligne."; puts(TEXTE); puts("Voici une deuxieme ligne."); printf("Tapez un texte\n"); gets(TEXTE); puts(TEXTE); //printf("Tapez un caractere\n"); a = getchar(); putchar(a); putchar('\n'); printf("Fin du travail\n"); return 0; }

2. Exercice 3
Ecrire un programme qui lit un caractre au clavier et affiche le caractre ainsi que son code numrique: a) en employant getchar et printf, Page 48 sur 217

Module Langage de programmation structure


b) en employant getch et printf.

D.

Correction des exercices

1. Exercice1
Voici les rsultats du programme : C : n=6 p=2 q=1 D : n=6 p=3 q=1 E : n=6 p=2 q=0 F : n=6 p=3 q=1 G:SS H : 83 83 I : 53 53

2. Exercice 2
#include <stdio.h> main() { int JOUR, MOIS, ANNEE, RECU; printf("Introduisez la date (JOUR, MOIS, ANNE) : "); RECU=scanf("%i %i %i", &JOUR, &MOIS, &ANNEE); printf("\ndonnes reues : %i\njour : %i\nmois : %i\nannee : %i\n", RECU, JOUR, MOIS, ANNEE); return 0; }

3. Exercice 3
a) en employant getchar et printf, #include <stdio.h> main() { int C; printf("Introduire un caractre suivi de 'Enter'\n"); C = getchar(); printf("Le caractre %c a le code ASCII %d\n", C, C); return 0; } b) en employant getch et printf. #include <stdio.h> #include <conio.h> main() Page 49 sur 217

Module Langage de programmation structure


{ int C; printf("Introduire un caractre \n"); C = getch(); printf("Le caractre %c a le code ASCII %d\n", C, C); return 0; }

VII.Les structures Alternatives


On a souvent besoin de n'effectuer certaines instructions que si des conditions sont remplies. On dispose pour cela du IF et du SWITCH.

A.

La structure if else (Si Sinon)

La syntaxe de la structure alternative en C est : if ( <expression> ) <bloc d'instructions 1> else <bloc d'instructions 2> Si l'<expression> fournit une valeur diffrente de zro, alors le <bloc d'instructions 1> est excut Si l'<expression> fournit la valeur zro, alors le <bloc d'instructions 2> est excut La partie <expression> peut dsigner : Une variable d'un type numrique, Une expression fournissant un rsultat numrique. La partie <bloc d'instructions> peut dsigner : Un (vrai) bloc d'instructions compris entre accolades {} Une seule instruction termine par un point-virgule

1. Exemple 1
if (a > b) max = a; else max = b;

2. Exemple 2
if (EGAL) printf("A est gal B\n"); else printf("A est diffrent de B\n");

Page 50 sur 217

Module Langage de programmation structure


3. Exemple 3
if (A-B) printf("A est diffrent de B\n"); else printf("A est gal B\n");

4. Exemple 4
if (A > B) { AIDE = A; A = C; C = AIDE; } else { AIDE = B; B = C; C = AIDE; }

5. Exemple 5
Ecrivez un programme en C qui saisi (ou lit) 2 valeurs au clavier, les compare et affiche la plus grande valeur. #include <stdio.h> #include <stdlib.h> int main () { float A,B,MAX; printf("Entrez les 2 valeurs A et B : "); scanf("%f %f",&A,&B); if (A>B) MAX = A; else MAX = B; printf("La plus grande des 2 valeurs est : %f\n",MAX); printf("Fin du travail\n"); system("pause"); return 0; }

6. Exemple 6
Ecrivez un programme qui lit 2 valeurs A et B, les change si A > B de manire les afficher dans lordre croissant. Page 51 sur 217

Module Langage de programmation structure

#include <stdio.h> #include <stdlib.h> int main () { float A,B,AUX; printf("Entrez les 2 valeurs A et B : "); scanf("%f %f",&A,&B); if (A>B) { AUX=B; B=A; A=AUX; // Echange de A et B } printf("La valeurs triees : %f %f\n",A,B); printf("Fin du travail\n"); system("pause"); return 0; }

B.

La structure if - else if - ... - else

En combinant plusieurs structures if - else en une expression nous obtenons une structure qui est trs courante pour prendre des dcisions entre plusieurs alternatives: if ( <expr1> ) <bloc1> else if (<expr2>) <bloc2> else if (<expr3>) <bloc3> else if (<exprN>) <blocN> else <blocN+1>

1. Exemple 1
#include <stdio.h> main() { int A,B; printf("Entrez deux nombres entiers :"); scanf("%i %i", &A, &B); if (A > B) Page 52 sur 217

Module Langage de programmation structure


printf("%i est plus grand que %i\n", A, B); else if (A < B) printf("%i est plus petit que %i\n", A, B); else printf("%i est gal %i\n", A, B); return 0; }

C.Les oprateurs conditionnels


Le langage C possde une paire d'oprateurs un peu exotiques qui peut tre utilise comme alternative if - else et qui a l'avantage de pouvoir tre intgre dans une expression: <expr1> ? <expr2> : <expr3> Si <expr1> fournit une valeur diffrente de zro, alors la valeur de <expr2> est fournie comme rsultat Si <expr1> fournit la valeur zro, alors la valeur de <expr3> est fournie comme rsultat

1. Exemple 1
La suite d'instructions if (A>B) MAX=A; else MAX=B; Peut tre remplace par: MAX = (A > B) ? A : B;

D.

La structure Switch - Case

Sa syntaxe est la suivante : switch (expression) { case valeur1: instructions ; break; case valeur2: instructions ; break; ........ case valeurN: instructions ; break; default : instructions ; break; }

Page 53 sur 217

Module Langage de programmation structure


1. Exemple 1
#include <stdio.h> #include <stdlib.h> int main () { int a; printf("Entrez la valeur de a : "); scanf("%d",&a); switch(a) { case 1:printf("a vaut 1\n"); break; case 2:printf("a vaut 2\n"); break; case 3:printf("a vaut 3\n"); break; default:printf("a non compris entre 1 et 3\n"); break; } printf("Fin du travail\n"); system("pause"); return 0; }

2. Exercice 1
Ecrivez un programme qui lit trois valeurs entires (A, B et C) au clavier et qui affiche la plus grande des trois valeurs, en utilisant: a) if - else et une variable d'aide MAX b) if - else if - ... - else sans variable d'aide c) les oprateurs conditionnels et une variable d'aide MAX d) les oprateurs conditionnels sans variable d'aide

3. Exercice 2
Ecrire un programme en C qui demande deux nombres lutilisateur et linforme ensuite si leur produit est ngatif ou positif (sans calculer le produit des deux nombres). Page 54 sur 217

Module Langage de programmation structure


4. Exercice 3
Ecrivez un programme qui lit deux valeurs entires (A et B) au clavier et qui affiche le signe de la somme de A et B sans faire l'addition. Utilisez la fonction fabs de la bibliothque <math>.

5. Exercice 4
Ecrivez un programme qui calcule les solutions relles d'une quation du second degr ax2+bx+c = 0 en discutant la formule:

Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et dcidez l'aide de D, si l'quation a une, deux ou aucune solution relle. Utilisez des variables du type int pour A, B et C. Considrez aussi les cas o l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et C. Affichez les rsultats et les messages ncessaires sur l'cran.

E.Correction des exercices


1. Exercice 1
a) if - else et une variable d'aide MAX #include <stdio.h> main() { int A, B, C; int MAX; printf("Introduisez trois nombres entiers :"); scanf("%i %i %i", &A, &B, &C); if (A>B) MAX=A; else MAX=B; if (C>MAX) MAX=C; printf("La valeur maximale est %i\n", MAX); return 0; } b) if - else if - ... - else sans variable d'aide int A, B, C; printf("Introduisez trois nombres entiers :"); scanf("%i %i %i", &A, &B, &C); printf("La valeur maximale est "); if (A>B && A>C) printf("%i\n",A); else if (B>C) Page 55 sur 217

Module Langage de programmation structure


printf("%i\n",B); else printf("%i\n",C); c) oprateurs conditionnels et une variable d'aide MAX int A, B, C; int MAX; printf("Introduisez trois nombres entiers :"); scanf("%i %i %i", &A, &B, &C); MAX = (A>B) ? A : B; MAX = (MAX>C) ? MAX : C; printf("La valeur maximale est %i\n", MAX); d) oprateurs conditionnels sans variable d'aide int A, B, C; printf("Introduisez trois nombres entiers :"); scanf("%i %i %i", &A, &B, &C); printf("La valeur maximale est %i\n", (A>((B>C)?B:C)) ? A : ((B>C)?B:C));

2. Exercice 2
1re Solution longue : #include<stdio.h> #include<stdlib.h> int main() { int a,b; printf("Entrez 2 entiers :"); scanf("%d %d",&a,&b); if ((a>0) && (b>0)) printf("Les 2 nombres sont de meme signe\n"); else if ((a>0) && (b<0)) printf("Les 2 nombres sont de signes contraires\n"); else if ((a<0) && (b>0)) printf("Les 2 nombres sont de signes contraires\n"); else printf("Les 2 nombres sont de meme signe\n"); system("pause"); return 0; } 2me Solution courte : #include<stdio.h> #include<stdlib.h> int main() Page 56 sur 217

Module Langage de programmation structure


{ int a,b; printf("Entrez 2 entiers :"); scanf("%d %d",&a,&b); if (((a>0) && (b>0)) || ((a<0) && (b<0))) printf("Les 2 nombres sont de meme signe\n"); else printf("Les 2 nombres sont de signes contraires\n"); system("pause"); return 0;

3. Exercice 3
#include <stdio.h> #include <math.h> main() { /* Afficher le signe de la somme de deux entiers sans faire l'addition */ int A, B; printf("Introduisez deux nombres entiers :"); scanf("%i %i", &A, &B); if ((A>0 && B>0) || (A<0 && B>0 && fabs(A)<fabs(B)) || (A>0 && B<0 && fabs(A)>fabs(B))) printf("Le signe de la somme %i + %i est positif\n",A,B); else if ((A<0 && B<0) || (A<0 && B>0 && fabs(A)>fabs(B)) || (A>0 && B<0 && fabs(A)<fabs(B))) printf("Le signe de la somme %i + %i est ngatif\n",A,B); else printf("La somme %i + %i est zro\n", A, B); return 0; }

4. Exercice4
#include <stdio.h> #include <math.h> main() { /* Calcul des solutions relles d'une quation du second degr */ int A, B, C; Page 57 sur 217

Module Langage de programmation structure


double D; /* Discriminant */ printf("Calcul des solutions relles d'une quation du second \n"); printf("degr de la forme ax^2 + bx + c = 0 \n\n"); printf("Introduisez les valeurs pour a, b, et c : "); scanf("%i %i %i", &A, &B, &C); /* Calcul du discriminant b^2-4ac */ D = pow(B,2) - 4.0*A*C; /* Distinction des diffrents cas */ if (A==0 && B==0 && C==0) /* 0x = 0 */ printf("Tout rel est une solution de cette quation.\n"); else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */ printf("Cette quation ne possde pas de solutions.\n"); else if (A==0) /* bx + c = 0 */ { printf("La solution de cette quation du premier degr est :\n"); printf(" x = %.4f\n", (double)C/B); } else if (D<0) /* b^2-4ac < 0 */ printf("Cette quation n'a pas de solutions relles.\n"); else if (D==0) /* b^2-4ac = 0 */ { printf("Cette quation a une seule solution relle :\n"); printf(" x = %.4f\n", (double)-B/(2*A)); } else /* b^2-4ac > 0 */ { printf("Les solutions relles de cette quation sont :\n"); printf(" x1 = %.4f\n", (-B+sqrt(D))/(2*A)); printf(" x2 = %.4f\n", (-B-sqrt(D))/(2*A)); } return 0; }

VIII. Les structures rptitives


En C, nous disposons de trois structures qui nous permettent la dfinition de boucles conditionnelles: 1) la structure : for 2) la structure : while 3) la structure : do - while

A.

Le structure for (Pour)

Cette boucle est utile quand on connat lavance le nombre ditrations effectuer. Sa structure est la suivante : for (expression_initiale; expr_condition; expr_incrmentation) Page 58 sur 217

Module Langage de programmation structure


<bloc dinstructions>

1. Exemple 1
Ecrivez un programme qui affiche les nombres de 1 10 : #include <stdio.h> #include <stdlib.h> int main () { int i; for (i=1; i<=10; i++) // i++ ou i=i+1 { // { : est facultative comme il n'y a qu'une seule instruction! printf("%d ",i); } printf("\nFin du travail\n"); system("pause"); return 0; }

B.

La structure While (tant que)

Sa structure est la suivante : while ( <expression> ) <bloc d'instructions> Tant que l'<expression> fournit une valeur diffrente de zro, le <bloc d'instructions> est excut. Si l'<expression> fournit la valeur zro, l'excution continue avec l'instruction qui suit le bloc d'instructions. Le <bloc d'instructions> est excut zro ou plusieurs fois.

1. Exemple 1
/* Afficher les nombres de 0 9 */ int I = 0; while (I<10) { printf("%i \n", I); I++; }

Page 59 sur 217

Module Langage de programmation structure


2. Exemple 2
/* Afficher les nombres de 10 1 */ int I=10; while (I) printf("%i \n", I--);

3. Exemple 3
Ecrivez un programme qui permet de saisir un entier N au clavier et qui calcule et affiche la somme : S = 1 + 2 + + N. #include <stdio.h> #include <stdlib.h> int main () { int N, S, i=1; printf("Saisir le nombre N : "); scanf("%d",&N); S=0; while (i<=N) { S=S+i; i++; } printf("La somme S = %d\n",S); printf("Fin du travail\n"); system("pause"); return 0; }

C.La structure do while (faire tant que)


Cette structure est comme le while, mais la diffrence fondamentale que l'instruction est au moins faite une fois ; Sa syntaxe est la suivante : do <bloc d'instructions> while ( <expression> ); Le <bloc d'instructions> est excut au moins une fois et aussi tant que l'<expression> fournit une valeur diffrente de zro.

Page 60 sur 217

Module Langage de programmation structure


1. Exemple 1
float N; do { printf("Introduisez un nombre entre 1 et 10 :"); scanf("%f", &N); } while (N<1 || N>10);

2. Exemple 2
int n, div; printf("Entrez le nombre diviser : "); scanf("%i", &n); do { printf("Entrez le diviseur ( 0) : "); scanf("%i", &div); } while (!div); printf("%i / %i = %f\n", n, div, (float)n/div);

3. Exemple 3
Le programme de calcul de la racine carre : #include <stdio.h> #include <math.h> main() { float N; do { printf("Entrer un nombre (>= 0) : "); scanf("%f", &N); } while (N < 0); printf("La racine carre de %.2f est %.2f\n", N, sqrt(N)); return 0; }

4. Exemple 4
Ecrivez un programme qui permet de saisir un entier N au clavier et qui calcule et affiche le factoriel N (N !) : produit : P = 1 x 2 x x N. #include <stdio.h> #include <stdlib.h> int main () Page 61 sur 217

Module Langage de programmation structure


{ int N, P, i=1; printf("Saisir le nombre N : "); scanf("%d",&N); P=1; do { P=P*i; i++; } while (i<=N); printf("Le factoriel N est = %d\n",P); printf("Fin du travail\n"); system("pause"); return 0; }

5. Exemple 5
Tapez le programme suivant : #include <stdio.h> #include <stdlib.h> int main () { int a; do { puts("veuillez entrer le nombre 2009"); scanf("%d",&a); } while (a!=2009); puts("c'est gentil de m'avoir obei"); printf("Fin du travail\n"); system("pause"); return 0; }

Page 62 sur 217

Module Langage de programmation structure


6. Exercice 1
Ecrivez un programme en C qui lit N valeurs relles saisies au clavier et qui calcule et affiche la somme S et la moyenne M de ces valeurs.

7. Exercice 2
Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme, leur produit et leur moyenne. Choisissez un type appropri pour les valeurs afficher. Le nombre N est entrer au clavier. Rsolvez ce problme, a) en utilisant while, b) en utilisant do - while, c) en utilisant for. d) Laquelle des trois variantes est la plus naturelle pour ce problme?

8. Exercice 3
Calculez par multiplications successives X N de deux entiers naturels X et N entrs au clavier.

9. Exercice 4
Calculez la somme des N premiers termes de la srie harmonique : 1 + 1/2 + 1/3 + ... + 1/N

10. Exercice 5
Calculez pour une valeur X donne du type float la valeur numrique d'un polynme de degr n: P(X) = AnXn + An-1Xn-1 + ... + A1X + A0 Les valeurs de n, des coefficients An, ... , A0 et de X seront entres au clavier. Utilisez le schma de Horner qui vite les oprations d'exponentiation lors du calcul:

Page 63 sur 217

Module Langage de programmation structure


11. Exercice 6
Calculez le P.G.C.D. de deux entiers naturels entrs au clavier en utilisant l'algorithme d'EUCLIDE

12. Exercice 7
Calculez le N-ime terme UN de la suite de FIBONACCI qui est donne par la relation de rcurrence: U1=1 U2=1 UN=UN-1 + UN-2 (pour N>2)

13. Exercice 8
Affichez un triangle isocle form d'toiles de N lignes (N est fourni au clavier): Nombre de lignes : 8 * *** ***** ******* ********* *********** ************* ***************

14. Exercice 9
Affiche la table des produits pour N variant de 1 10 : X*Y I 0 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------0 I 0 0 0 0 0 0 0 0 0 0 0 1 I 0 1 2 3 4 5 6 7 8 9 10 2 I 0 2 4 6 8 10 12 14 16 18 20 3 I 0 3 6 9 12 15 18 21 24 27 30 4 I 0 4 8 12 16 20 24 28 32 36 40 5 I 0 5 10 15 20 25 30 35 40 45 50 6 I 0 6 12 18 24 30 36 42 48 54 60 7 I 0 7 14 21 28 35 42 49 56 63 70 8 I 0 8 16 24 32 40 48 56 64 72 80 9 I 0 9 18 27 36 45 54 63 72 81 90 10 I 0 10 20 30 40 50 60 70 80 90 100

D.

Correction des exercices

1. Exercice 1
#include <stdio.h> Page 64 sur 217

Module Langage de programmation structure


#include <stdlib.h> int main () { int i,N; float S,M,V; S=0; printf("entrez le nombre de valeurs N : "); scanf("%d",&N); printf("entrez le N valeurs : "); for (i=1;i<=N;i++) { scanf("%f",&V); S=S+V; } M=S/N; printf("la somme des N valeurs est S = %f\n",S); printf("la moyenne des N valeurs est M = %f\n",M); printf("Fin du travail\n"); system("pause"); return 0; }

2. Exercice 2
a) en utilisant while, #include <stdio.h> main() { int N; /* nombre de donnes */ int NOMB; /* nombre courant */ int I; /* compteur */ long SOM; /* la somme des nombres entrs */ double PROD; /* le produit des nombres entrs */ printf("Nombre de donnes : "); scanf("%d", &N); SOM=0; PROD=1; I=1; while(I<=N) { printf("%d. nombre : ", I); Page 65 sur 217

Module Langage de programmation structure


scanf("%d", &NOMB); SOM += NOMB; PROD *= NOMB; I++; } printf("La somme des %d nombres est %ld \n", N, SOM); printf("Le produit des %d nombres est %.0f\n", N, PROD); printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N); return 0; } b) en utilisant do - while, Remplacez le bloc de traitement (en gras) de (a) par : SOM=0; PROD=1; I=1; do { printf("%d. nombre : ", I); scanf("%d", &NOMB); SOM += NOMB; PROD *= NOMB; I++; } while(I<=N); c) en utilisant for. Remplacez le bloc de traitement (en gras) de (a) par : for (SOM=0, PROD=1, I=1 ; I<=N ; I++) { printf("%d. nombre : ", I); scanf("%d", &NOMB); SOM += NOMB; PROD *= NOMB; } d) Laquelle des trois variantes est la plus naturelle pour ce problme? La structure for est la plus compacte et celle qui exprime le mieux l'ide de l'algorithme. D'autre part, elle permet d'intgrer trs confortablement l'initialisation et l'incrmentation des variables dans la structure.

3. Exercice 3
#include <stdio.h> main() { int X, N; /* Les donnes */ int I; /* Le compteur */ double RESU; /* Type double cause de la */ /* grandeur du rsultat. */ Page 66 sur 217

Module Langage de programmation structure


do { printf("Entrez l'entier naturel X : "); scanf("%d", &X); } while (X<0); do { printf("Entrez l'exposant N : "); scanf("%d", &N); } while (N<0); /* Pour N=0, le rsultat sera automatiquement X^0=1 */ for (RESU=1.0, I=1 ; I<=N ; I++) RESU*=X; /* Attention: Pour X=0 et N=0 , 0^0 n'est pas dfini */ if (N==0 && X==0) printf("zro exposant zro n'est pas dfini !\n"); else printf("Rsultat : %d ^ %d = %.0f\n", X, N, RESU); return 0; }

4. Exercice 4
#include <stdio.h> main() { int N; /* nombre de termes calculer */ int I; /* compteur pour la boucle */ float SOM; /* Type float cause de la prcision du rsultat. */ do { printf ("Nombre de termes: "); scanf ("%d", &N); } while (N<1); for (SOM=0.0, I=1 ; I<=N ; I++) SOM += (float)1/I; printf("La somme des %d premiers termes est %f \n", N, SOM); return 0; }

Page 67 sur 217

Module Langage de programmation structure


5. Exercice 5
#include <stdio.h> main() { int N; /* degr du polynme */ float X; /* argument */ float A; /* coefficients successifs du polynme */ float P; /* coefficient courant du terme Horner */ printf("Entrer le degr N du polynme : "); scanf("%d", &N); printf("Entrer la valeur X de l'argument : "); scanf("%f", &X); for(P=0.0 ; N>=0 ; N--) { printf("Entrer le coefficient A%d : ", N); scanf("%f", &A); P = P*X + A; } printf("Valeur du polynme pour X = %.2f : %.2f\n", X, P); return 0; }

6. Exercice 6
#include <stdio.h> main() { int A, B; /* donnes */ int X, Y, RESTE; /* var. d'aide pour l'algorithme d'Euclide */ do { printf("Entrer l'entier A (non nul) : "); scanf("%d", &A); } while(!A); do { printf("Entrer l'entier B (non nul) : "); scanf("%d", &B); } while(!B); RESTE=A ; X=A ; Y=B ; Page 68 sur 217

Module Langage de programmation structure


for ( ; RESTE ; ) { RESTE = X%Y; X=Y ; Y=RESTE ; } printf("Le PGCD de %d et de %d est %d\n", A, B, X); return 0; } Remarque :pour une meilleur reprsentation on peux utiliser : for (RESTE=A, X=A, Y=B ; RESTE ; X=Y, Y=RESTE) RESTE = X%Y;

7. Exercice 7
#include <stdio.h> main() { int U1, U2, UN; /* pour parcourir la suite */ int N; /* rang du terme demand */ int I; /* compteur pour la boucle */ do { printf("Rang du terme demand : "); scanf("%d", &N); } while(N<1); U1=U2=1; /* Initialisation des deux premiers termes */ if (N==1) UN=U1; else if (N==2) UN=U2; else { for (I=3 ; I<=N ; I++) { UN = U1+U2; U1 = U2; U2 = UN; } } printf("Valeur du terme de rang %d : %d\n", N, UN); return 0; }

Page 69 sur 217

Module Langage de programmation structure


8. Exercice 8
#include <stdio.h> main() { int LIG; /* nombre de lignes */ int L; /* compteur des lignes */ int ESP; /* nombre d'espaces */ int I; /* compteur des caractres */ do { printf("Nombres de lignes : "); scanf("%d", &LIG); } while (LIG<1 || LIG>20); for (L=0 ; L<LIG ; L++) { ESP = LIG-L-1; for (I=0 ; I<ESP ; I++) putchar(' '); for (I=0 ; I<2*L+1 ; I++) putchar('*'); putchar('\n'); } return 0; }

9. Exercice 9
#include <stdio.h> main() { const int MAX = 10; /* nombre de lignes et de colonnes */ int I; /* compteur des lignes */ int J; /* compteur des colonnes */ /* Affichage de l'en-tte */ printf(" X*Y I"); for (J=0 ; J<=MAX ; J++) printf("%4d", J); printf("\n"); printf("------"); for (J=0 ; J<=MAX ; J++) printf("----"); printf("\n"); /* Affichage du tableau */ Page 70 sur 217

Module Langage de programmation structure


for (I=0 ; I<=MAX ; I++) { printf("%3d I", I); for (J=0 ; J<=MAX ; J++) printf("%4d", I*J); printf("\n"); } return 0; }

IX. Les structures de donnes avances


A. Tableaux ou vecteurs
1. Dfinition
Un tableau (uni-dimensionnel) A est une variable structure forme d'un nombre entier N de variables simples du mme type, qui sont appeles les composantes du tableau. Le nombre de composantes N est alors la dimension du tableau.

int JOURS[12]={31,28,31,30,31,30,31,31,30,31,30,31}; Dfinit un tableau du type int de dimension 12. Les 12 composantes sont initialises par les valeurs respectives 31, 28, 31, ..., 31. On peut accder la premire composante du tableau par JOURS[0], la deuxime composante par JOURS[1], . . . , la dernire composante par JOURS[11].

2. Dclaration de tableaux en C
Syntaxe : type nom_du_tableau [nombre_d'lments]; Exemple : int tab[10]; Ceci rserve en mmoire un espace pouvant contenir 10 entiers. Le premier est tab[0], jusqu' tab[9] On peut aussi dclarer un tableau par typedef : Page 71 sur 217

Module Langage de programmation structure


typedef float vecteur[3] ; vecteur x,y ; On peut aussi initialiser un tableau lors de sa dclaration : int T[4] = {10,20,30,40} ; Comme on peut ne pas spcifier la dimension du tableau : int Y[ ] = {3,5,7} ;

3. Remarque
En C, le nom d'un tableau est le reprsentant de l'adresse du premier lment du tableau. Les adresses des autres composantes sont calcules (automatiquement) relativement cette adresse. Exemple: short A[5] = {1200, 2300, 3400, 4500, 5600};

Si un tableau est form de N composantes et si une composante a besoin de M octets en mmoire, alors le tableau occupera de N*M octets. En supposant qu'une variable du type long occupe 4 octets (c.--d: sizeof(long)=4), pour le tableau T dclar par: long T[15]; C rservera N*M = 15*4 = 60 octets en mmoire.

4. Initialisation et rservation automatique


a) Initialisation
Lors de la dclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la liste des valeurs respectives entre accolades. int A[5] = {10, 20, 30, 40, 50}; float B[4] = {-1.05, 3.33, 87e-5, -12.3E4}; int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1}; Il faut videmment veiller ce que le nombre de valeurs dans la liste corresponde la dimension du tableau. Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes restantes sont initialises par zro.

Page 72 sur 217

Module Langage de programmation structure


b) Rservation automatique
Si la dimension n'est pas indique explicitement lors de l'initialisation, alors l'ordinateur rserve automatiquement le nombre d'octets ncessaires. int A[] = {10, 20, 30, 40, 50}; ==> rservation de 5*sizeof(int) octets (dans notre cas: 10 octets) float B[] = {-1.05, 3.33, 87e-5, -12.3E4}; ==> rservation de 4*sizeof(float) octets (dans notre cas: 16 octets) int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

==> rservation de 10*sizeof(int) octets (dans notre cas: 20 octets)

c) Exemple

5. Accs aux composantes


En dclarant un tableau par: int A[5]; Page 73 sur 217

Module Langage de programmation structure


Nous avons dfini un tableau A avec cinq composantes, auxquelles on peut accder par: A[0], A[1], ... , A[4]

a) Exemples

En C: L'accs au premier lment du tableau se fait par T[0] l'accs au dernier lment du tableau se fait par T[N-1]

6. Affectation et affichage
La structure for se prte particulirement bien au travail avec les tableaux.

a) Affectation
main() { int A[5]; int I; /* Compteur */ for (I=0; I<5; I++) scanf("%d", &A[I]); return 0; } Comme scanf a besoin des adresses des diffrentes composantes du tableau, il faut faire prcder le terme A[I] par l'oprateur adresse '&'.

b) Affichage
main() { int A[5]; int I; /* Compteur */ for (I=0; I<5; I++) printf("%d ", A[I]); return 0; printf("\n"); } Page 74 sur 217

Module Langage de programmation structure


7. Exemple 1
Dans cet exemple, on va sommer 2 vecteurs et afficher le vecteur rsultat : #include <stdio.h> #include <stdlib.h> int main () { int i; typedef int vecteur[4]; vecteur U={1,2,3,4},V={1,2,3,4},W; for(i=0;i<=3;i++) { W[i]=U[i]+V[i]; printf("%d ",W[i]); } printf("\nFin du travail\n"); system("pause"); return 0; }

8. Exercice 1
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Calculer et afficher ensuite la somme des lments du tableau

9. Exercice 2
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T. Afficher le tableau rsultant

Page 75 sur 217

Module Langage de programmation structure


10. Exercice 3
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Ranger ensuite les lments du tableau T dans l'ordre inverse sans utiliser de tableau d'aide. Afficher le tableau rsultant. Ide: Echanger les lments du tableau l'aide de deux indices qui parcourent le tableau en commenant respectivement au dbut et la fin du tableau et qui se rencontrent en son milieu

11. Exercice 4
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Copiez ensuite toutes les composantes strictement positives dans un deuxime tableau TPOS et toutes les valeurs strictement ngatives dans un troisime tableau TNEG. Afficher les tableaux TPOS et TNEG.

12. Exercice 5
Ecrire un programme qui permet de lire un tableau de N valeurs relles (on suppose N < 20), et qui permet de : 1. Chercher et afficher le maximum des valeurs du tableau. 2. Compter et afficher le nombre de valeurs ngatives du tableau. 3. Rechercher si une valeur se trouve dans le tableau et afficher trouv ou non trouv selon les cas. (Utilisez la boucle while ou dowhile). 4. Calculer et afficher la somme et la moyenne des valeurs strictement positives du tableau. 5. Multiplier toutes les valeurs du tableau par 5 et dafficher le rsultat obtenu.

13. Exercice 6
Ecrire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de mme dimension). Exemple:

/ | 3 \

\ / -4 | * | 2 / \

-3

\ 5 | = 3*2+2*(-3)+(-4)*5 = -20 /

Page 76 sur 217

Module Langage de programmation structure


14. Exercice 7
Calculer pour une valeur X donne du type float la valeur numrique d'un polynme de degr n: P(X) = AnXn + An-1Xn-1 + ... + A1X + A0 Les valeurs des coefficients An, ... , A0 seront entres au clavier et mmorises dans un tableau A de type float et de dimension n+1. a) Utilisez la fonction pow() pour le calcul. b) Utilisez le schma de Horner qui vite les oprations d'exponentiation:

15. Exercice 8
Problme: Rechercher dans un tableau d'entiers A une valeur VAL entre au clavier. Afficher la position de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La valeur POS qui est utilise pour mmoriser la position de la valeur dans le tableau, aura la valeur -1 aussi longtemps que VAL n'a pas t trouve. Implmenter deux versions: a) La recherche squentielle Comparer successivement les valeurs du tableau avec la valeur donne. b) La recherche dichotomique ('recherche binaire', 'binary search') Condition: Le tableau A doit tre tri Comparer le nombre recherch la valeur au milieu du tableau, - s'il y a galit ou si le tableau est puis, arrter le traitement avec un message correspondant. Page 77 sur 217

Module Langage de programmation structure


- si la valeur recherche prcde la valeur actuelle du tableau, continuer la recherche dans le demi-tableau gauche de la position actuelle. - si la valeur recherche suit la valeur actuelle du tableau, continuer la recherche dans le demitableau droite de la position actuelle. Ecrire le programme pour le cas o le tableau A est tri par ordre croissant. Question: Quel est l'avantage de la recherche dichotomique? Expliquer brivement.

16. Exercice 9
Problme: On dispose de deux tableaux A et B (de dimensions respectives N et M), tris par ordre croissant. Fusionner les lments de A et B dans un troisime tableau FUS tri par ordre croissant. Mthode: Utiliser trois indices IA, IB et IFUS. Comparer A[IA] et B[IB]; remplacer FUS[IFUS] par le plus petit des deux lments; avancer dans le tableau FUS et dans le tableau qui a contribu son lment. Lorsque l'un des deux tableaux A ou B est puis, il suffit de recopier les lments restants de l'autre tableau dans le tableau FUS.

17. Exercice 10
Ecrire un programme qui lit les points de N lves d'une classe dans un devoir et les mmorise dans un tableau POINTS de dimension N. * Rechercher et afficher: - la note maximale, - la note minimale, - la moyenne des notes. * A partir des POINTS des lves, tablir un tableau NOTES de dimension 7 qui est compos de la faon suivante: NOTES[6] contient le nombre de notes 60 NOTES[5] contient le nombre de notes de 50 59 NOTES[4] contient le nombre de notes de 40 49 Page 78 sur 217

Module Langage de programmation structure


... NOTES[0] contient le nombre de notes de 0 9 Etablir un graphique de barreaux reprsentant le tableau NOTES. Utilisez les symboles ####### pour la reprsentation des barreaux et affichez le domaine des notes en dessous du graphique. Ide: Dterminer la valeur maximale MAXN dans le tableau NOTES et afficher autant de lignes sur l'cran. (Dans l'exemple ci-dessous, MAXN = 6). Exemple: La note maximale est 58 La note minimale est 13 La moyenne des notes est 37.250000 6 5 4 3 2 1 > > > > > > ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### +-------+-------+-------+-------+-------+-------+-------+ I 0 - 9 I 10-19 I 20-29 I 30-39 I 40-49 I 50-59 I 60 I

B.

Les tableaux deux dimensions ou matrices

1. Dfinition
En C, un tableau deux dimensions A est interprter comme un tableau (uni-dimensionnel) de dimension L dont chaque composante est un tableau (uni-dimensionnel) de dimension C. On appelle L le nombre de lignes du tableau et C le nombre de colonnes du tableau. L et C sont alors les deux dimensions du tableau. Un tableau deux dimensions contient donc L*C composantes.

Page 79 sur 217

Module Langage de programmation structure

On dit qu'un tableau deux dimensions est carr, si L est gal C. En faisant le rapprochement avec les mathmatiques, on peut dire que "A est un vecteur de L vecteurs de dimension C", ou mieux: "A est une matrice de dimensions L et C".

2. Exemple
Considrons un tableau NOTES une dimension pour mmoriser les notes de 20 lves d'une classe dans un devoir: int NOTE[20] = {45, 34, ... , 50, 48};

Pour mmoriser les notes des lves dans les 10 devoirs d'un trimestre, nous pouvons rassembler plusieurs de ces tableaux uni-dimensionnels dans un tableau NOTES deux dimensions : int NOTE[10][20] = {{45, 34, ... , 50, 48}, {39, 24, ... , 49, 45}, ... ... ... {40, 40, ... , 54, 44}};

Page 80 sur 217

Module Langage de programmation structure

Dans une ligne nous retrouvons les notes de tous les lves dans un devoir. Dans une colonne, nous retrouvons toutes les notes d'un lve.

3. Dclaration et mmorisation
a) Dclaration
Pour dclarer un tableau deux dimension dans le langage C on utilise la syntaxe suivante: <Type> <NomTabl>[<DimLigne>][<DimCol>]; Exemple : float B[2][20];

b) Mmorisation
Comme pour les tableaux une dimension, le nom d'un tableau est le reprsentant de l'adresse du premier lment du tableau (c.--d. l'adresse de la premire ligne du tableau). Les composantes d'un tableau deux dimensions sont stockes ligne par ligne dans la mmoire. Exemple: short A[3][2] = {{1, 2 }, {10, 20 }, {100, 200}};

Un tableau de dimensions L et C, form de composantes dont chacune a besoin de M octets, occupera L*C*M octets en mmoire. Exemple: Page 81 sur 217

Module Langage de programmation structure


En supposant qu'une variable du type double occupe 8 octets (c.--d: sizeof(double)=8), pour le tableau T dclar par: double T[10][15]; C rservera L*C*M = 10*15*8 = 1200 octets en mmoire.

4. Initialisation et rservation automatique


a) Initialisation
Lors de la dclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la liste des valeurs respectives entre accolades. A l'intrieur de la liste, les composantes de chaque ligne du tableau sont encore une fois comprises entre accolades. Pour amliorer la lisibilit des programmes, on peut indiquer les composantes dans plusieurs lignes. Exemple : int A[3][10] ={{ 0,10,20,30,40,50,60,70,80,90}, {10,11,12,13,14,15,16,17,18,19}, { 1,12,23,34,45,56,67,78,89,90}}; float B[3][2] = {{-1.05, -1.10 }, {86e-5, 87e-5 }, {-12.5E4, -12.3E4}}; Lors de l'initialisation, les valeurs sont affectes ligne par ligne en passant de gauche droite. Nous ne devons pas ncessairement indiquer toutes les valeurs: Les valeurs manquantes seront initialises par zro. Il est cependant dfendu d'indiquer trop de valeurs pour un tableau. Exemple :

Page 82 sur 217

Module Langage de programmation structure

b) Rservation automatique
Si le nombre de lignes L n'est pas indiqu explicitement lors de l'initialisation, l'ordinateur rserve automatiquement le nombre d'octets ncessaires. int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90}, {10,11,12,13,14,15,16,17,18,19}, { 1,12,23,34,45,56,67,78,89,90}}; Rservation de 3*10*2 = 60 octets float B[][2] = {{-1.05, -1.10 }, {86e-5, 87e-5 }, {-12.5E4, -12.3E4}}; Rservation de 3*2*4 = 24 octets

Page 83 sur 217

Module Langage de programmation structure


Exemple :

5. Accs aux composantes


L'accs un tableau en langage C se fait da a manire suivante: <NomTableau>[<Ligne>][<Colonne>] Les lments d'un tableau de dimensions L et C se prsentent de la faon suivante: / | A[0][0] | A[1][0] | A[2][0] | ... .. | A[L-1][0] \ \ | | | | A[L-1][C-1] | /

A[0][1] A[0][2] . . . A[1][1] A[1][2] . . . A[2][1] A[2][2] . . . . ... ... ... A[L-1][1] A[L-1][2] . . .

A[0][C-1] A[1][C-1] A[2][C-1]

En langage C : Les indices du tableau varient de 0 L-1, respectivement de 0 C-1. La composante de la Nime ligne et Mime colonne est note: A[N,M]

6. Affectation et affichage
Lors du travail avec les tableaux deux dimensions, nous utiliserons deux indices (p.ex: I et J), et la structure for, souvent imbrique, pour parcourir les lignes et les colonnes des tableaux.

Page 84 sur 217

Module Langage de programmation structure


a) Affectation
main() { int A[5][10]; int I,J; /* Pour chaque ligne ... */ for (I=0; I<5; I++) /* ... considrer chaque composante */ for (J=0; J<10; J++) scanf("%d", &A[I][J]); return 0; }

b) Affichage
main() { int A[5][10]; int I,J; /* Pour chaque ligne ... */ for (I=0; I<5; I++) { /* ... considrer chaque composante */ for (J=0; J<10; J++) printf("%7d", A[I][J]); /* Retour la ligne */ printf("\n"); } return 0; }

7. Exercice 11
Ecrire un programme qui lit les dimensions L et C d'un tableau T deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entres au clavier et afficher le tableau ainsi que la somme de tous ses lments.

8. Exercice 12
Ecrire un programme qui lit les dimensions L et C d'un tableau T deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entres au clavier et afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne en n'utilisant qu'une variable d'aide pour la somme.

Page 85 sur 217

Module Langage de programmation structure


9. Exercice 13
Ecrire un programme qui transfre un tableau M deux dimensions L et C (dimensions maximales: 10 lignes et 10 colonnes) dans un tableau V une dimension L*C. Exemple:

/ \ | a b c d | | e f g h | | i j k l | \ /

==>

/ \ | a b c d e f g h i j k l | \ /

10. Exercice 14
Ecrire un programme en C qui permet de saisir, de compter et dafficher le nombre de zros (0) dune matrice (3 lignes, 3 colonnes).

11. Exercice 15
Ecrire un programme qui met zro les lments de la diagonale principale d'une matrice carre A donne.

12. Exercice 16
Ecrire un programme qui construit et affiche une matrice carre unitaire U de dimension N. Une matrice unitaire est une matrice, telle que: / 1 si i=j uij = | \ 0 si i#j

13. Exercice 17
Ecrire un programme qui effectue la transposition t A d'une matrice A de dimensions N et M en une matrice de dimensions M et N. a) La matrice transpose sera mmorise dans une deuxime matrice B qui sera ensuite affiche. b) La matrice A sera transpose par permutation des lments.

Page 86 sur 217

Module Langage de programmation structure


Rappel:

tA =

/ \ t | a b c d | | e f g h | | i j k l | \ /

/ | | | | \

a b c d

e f g h

i j k l

\ | | | | /

14. Exercice 18
Ecrire un programme qui ralise la multiplication d'une matrice A par un rel X. Rappel:

/ \ | a b c d | X * | e f g h | | i j k l | \ /

/ \ | X*a X*b X*c X*d | | X*e X*f X*g X*h | | X*i X*j X*k X*l | \ /

a) Le rsultat de la multiplication sera mmoris dans une deuxime matrice A qui sera ensuite affiche. b) Les lments de la matrice A seront multiplis par X.

15. Exercice 19
Ecrire un programme qui ralise l'addition de deux matrices A et B de mmes dimensions N et M. Rappel:

/ \ / \ | a b c d | | a' b' c' d' | | e f g h | + | e' f' g' h' | | i j k l | | i' j' k' l' | \ / \ /

/ \ | a+a' b+b' c+c' d+d' | | e+e' f+f' g+g' h+h' | | i+i' j+j' k+k' l+l' | \ /

a) Le rsultat de l'addition sera mmoris dans une troisime matrice C qui sera ensuite affiche. b) La matrice B est ajoute A.

Page 87 sur 217

Module Langage de programmation structure


16. Exercice 20
En multipliant une matrice A de dimensions N et M avec une matrice B de dimensions M et P on obtient une matrice C de dimensions N et P: A(N,M) * B(M,P) = C(N,P) La multiplication de deux matrices se fait en multipliant les composantes des deux matrices lignes par colonnes:

Rappel:

/ | | | | \

a e h k

b f i l

c g j m

\ | | | | /

/ \ | p q | | r s | | t u | \ /

/ | | | | \

a*p e*p h*p k*p

+ + + +

b*r f*r i*r l*r

+ + + +

c*t g*t j*t m*t

a*q e*q h*q k*q

+ + + +

b*s f*s i*s l*s

+ + + +

c*u g*u j*u m*u

\ | | | | /

Ecrire un programme qui effectue la multiplication de deux matrices A et B. Le rsultat de la multiplication sera mmoris dans une troisime matrice C qui sera ensuite affiche.

17. Exercice 21
Ecrire un programme qui construit le triangle de PASCAL de degr N et le mmorise dans une matrice carre P de dimension N+1. Exemple: Triangle de Pascal de degr 6:

n=0 n=1 n=2 n=3 n=4 n=5 n=6

1 11 121 133 1 146 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1

Mthode: Page 88 sur 217

Module Langage de programmation structure


Calculer et afficher seulement les valeurs jusqu' la diagonale principale (incluse). Limiter le degr entrer par l'utilisateur 13. Construire le triangle ligne par ligne: - Initialiser le premier lment et l'lment de la diagonale 1. - Calculer les valeurs entre les lments initialiss de gauche droite en utilisant la relation: Pi,j = Pi-1,j + Pi-1,j-1

C.Correction des exercices


1. Exercice 1
#include <stdio.h> main() { /* Dclarations */ int T[50]; /* tableau donn */ int N; /* dimension */ int I; /* indice courant */ long SOM; /* somme des lments - type long cause */ /* de la grandeur prvisible du rsultat. */ /* Saisie des donnes */ printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &T[I]); } /* Affichage du tableau */ printf("Tableau donn :\n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); /* Calcul de la somme */ for (SOM=0, I=0; I<N; I++) SOM += T[I]; /* Edition du rsultat */ printf("Somme de lments : %ld\n", SOM); return 0; }

Page 89 sur 217

Module Langage de programmation structure


2. Exercice 2
#include <stdio.h> main() { /* Dclarations */ int T[50]; /* tableau donn */ int N; /* dimension */ int I,J; /* indices courants */ /* Saisie des donnes */ printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &T[I]); } /* Affichage du tableau */ printf("Tableau donn : \n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); /* Effacer les zros */ /* Copier tous les lments de I vers J et */ /* augmenter J pour les lments non nuls. */ for (I=0, J=0 ; I<N ; I++) { T[J] = T[I]; if (T[I]) J++; } /* Nouvelle dimension du tableau ! */ N = J; /* Edition des rsultats */ printf("Tableau rsultat :\n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); return 0; }

3. Exercice 3
#include <stdio.h> main() { /* Dclarations */ int T[50]; /* tableau donn */
Page 90 sur 217

Module Langage de programmation structure


int N; /* dimension */ int I,J; /* indices courants */ int AIDE; /* pour l'change */ /* Saisie des donnes */ printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &T[I]); } /* Affichage du tableau */ printf("Tableau donn : \n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); /* Inverser le tableau */ for (I=0, J=N-1 ; I<J ; I++,J--) /* Echange de T[I] et T[J] */ { AIDE = T[I]; T[I] = T[J]; T[J] = AIDE; } /* Edition des rsultats */ printf("Tableau rsultat :\n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); return 0; }

4. Exercice 4
#include <stdio.h> main() { /* Dclarations */ /* Les tableaux et leurs dimensions */ int T[50], TPOS[50], TNEG[50]; int N, NPOS, NNEG; int I; /* indice courant */ /* Saisie des donnes */ Page 91 sur 217

Module Langage de programmation structure


printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &T[I]); } /* Affichage du tableau */ printf("Tableau donn :\n"); for (I=0; I<N; I++) printf("%d ", T[I]); printf("\n"); /* Initialisation des dimensions de TPOS et TNEG */ NPOS=0; NNEG=0; /* Transfer des donnes */ for (I=0; I<N; I++) { if (T[I]>0) { TPOS[NPOS]=T[I]; NPOS++; } if (T[I]<0) { TNEG[NNEG]=T[I]; NNEG++; } } /* Edition du rsultat */ printf("Tableau TPOS :\n"); for (I=0; I<NPOS; I++) printf("%d ", TPOS[I]); printf("\n"); printf("Tableau TNEG :\n"); for (I=0; I<NNEG; I++) printf("%d ", TNEG[I]); printf("\n"); return 0; }

5. Exercice 5
#include <stdio.h> #include <stdlib.h> int main (){ int N,compt_neg=0,compt_pos=0,j=0; float S=0.0,max,V,moy,T[20];//T : tableau de 20 reels printf("Entrez la dimension du tableau :"); scanf("%d",&N); Page 92 sur 217

Module Langage de programmation structure


//lecture du tableau : printf("Entrez les N valeurs du tableau :"); for (int i=0;i<N;i++) scanf("%f",&T[i]); //1.Chercher et afficher le maximum des valeurs du tableau : max=T[0]; for (int i=1;i<N;i++) if (T[i]>max) max=T[i]; printf("Le maximum des valeurs du tableau est : %.2f\n",max); //2.Compter et afficher le nombre de valeurs ngatives du tableau : for (int i=0;i<N;i++) if (T[i]<0)compt_neg++; printf("Le nombre de valeurs negatives du tableau est : %d\n",compt_neg); //3.Rechercher si une valeur se trouve dans le tableau : printf("Entrez la valeur recherchee :"); scanf("%f",&V); while ((T[j]!=V) && (j<=N)) j++; if (j<N) printf("Valeur trouvee\n"); else printf("Valeur non trouvee\n"); //4.Calculer et afficher la somme et la moyenne des valeurs strictement positives du tableau : for (int i=0;i<N;i++) if (T[i]>0) { S=S+T[i]; compt_pos++; } moy=S/compt_pos; printf("La somme des valeurs strictement positives du tableau est : %.2f\n",S); printf("La moyenne %.2f\n",moy); des valeurs strictement positives du tableau est :

//5.Multiplier toutes les valeurs du tableau par 5 et d'afficher le rsultat obtenu : printf("Affichage des valeurs du tableau * 5 :\n"); for (int i=0;i<N;i++) printf("%10.2f",5*T[i]); printf("\n"); system("pause"); return 0; }

Page 93 sur 217

Module Langage de programmation structure

6. Exercice 6
#include <stdio.h> main() { int U[50], V[50]; /* tableaux donns */ int N; /* dimension */ int I; /* indice courant */ long PS; /* produit scalaire */ /* Saisie des donnes */ printf("Dimension des tableaux (max.50) : "); scanf("%d", &N ); printf("** Premier tableau **\n"); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &U[I]); } printf("** Deuxime tableau **\n"); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &V[I]); } /* Calcul du produit scalaire */ for (PS=0, I=0; I<N; I++) PS += (long)U[I]*V[I]; /* Edition du rsultat */ printf("Produit scalaire : %ld\n", PS); return 0; }

7. Exercice 7
#include <stdio.h> #include <math.h> Page 94 sur 217

Module Langage de programmation structure


main() { float A[20];/* tableau des coefficients de P */ int I; /* indice courant */ int N; /* degr du polynme */ float X; /* argument */ float P; /* rsultat */ /* Saisie du degr N et de l'argument X */ printf("Entrer le degr N du polynme (max.20) : "); scanf("%d", &N); printf("Entrer la valeur X de l'argument : "); scanf("%f", &X); /* Saisie des coefficients */ for (I=0 ; I<=N ; I++) { printf("Entrer le coefficient A%d : ", I); scanf("%f", &A[I]); } /* a) Calcul l'aide de pow for (P=0.0, I=0 ; I<=N ; I++) P += A[I]*pow(X,I); */ /* b) Calcul de Horner */ /* commencer le calcul avec le dernier coefficient...*/ for (P=0.0, I=0 ; I<=N ; I++) P = P*X + A[N-I]; /* Edition du rsultat */ printf("Valeur du polynme pour X = %.2f : %.2f\n", X, P); return 0; }

8. Exercice 8
a) La recherche squentielle Comparer successivement les valeurs du tableau avec la valeur donne. #include <stdio.h> main() { /* Dclarations */ int A[50]; /* tableau donn */ int VAL; /* valeur rechercher */ int POS; /* position de la valeur */ int N; /* dimension */ Page 95 sur 217

Module Langage de programmation structure


int I; /* indice courant */

/* Saisie des donnes */ printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", &A[I]); } printf("Elment rechercher : "); scanf("%d", &VAL ); /* Affichage du tableau */ printf("Tableau donn : \n"); for (I=0; I<N; I++) printf("%d ", A[I]); printf("\n"); /* Recherche de la position de la valeur */ POS = -1; for (I=0 ; (I<N)&&(POS==-1) ; I++) if (A[I]==VAL) POS=I; /* Edition du rsultat */ if (POS==-1) printf("La valeur recherche ne se trouve pas " "dans le tableau.\n"); else printf("La valeur %d se trouve la position %d. \n", VAL, POS); return 0; } b) La recherche dichotomique ('recherche binaire', 'binary search') #include <stdio.h> main() { /* Dclarations */ int A[50]; /* tableau donn */ int VAL; /* valeur rechercher */ int POS; /* position de la valeur */ int N; /* dimension */ int I; /* indice courant */ int INF, MIL, SUP; /* limites du champ de recherche */ /* Saisie des donnes */ printf("Dimension du tableau (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) Page 96 sur 217

Module Langage de programmation structure


{ printf("Elment %d : ", I); scanf("%d", &A[I]); } printf("Elment rechercher : "); scanf("%d", &VAL ); /* Affichage du tableau */ printf("Tableau donn : \n"); for (I=0; I<N; I++) printf("%d ", A[I]); printf("\n"); /* Initialisation des limites du domaine de recherche */ INF=0; SUP=N-1; /* Recherche de la position de la valeur */ POS=-1; while ((INF<=SUP) && (POS==-1)) { MIL=(SUP+INF)/2; if (VAL < A[MIL]) SUP=MIL-1; else if (VAL > A[MIL]) INF=MIL+1; else POS=MIL; } /* Edition du rsultat */ if (POS==-1) printf("La valeur recherche ne se trouve pas " "dans le tableau.\n"); else printf("La valeur %d se trouve la position %d. \n", VAL, POS); return 0; } Question: Quel est l'avantage de la recherche dichotomique? Dans le pire des cas d'une recherche squentielle, il faut traverser tout le tableau avant de trouver la valeur ou avant d'tre sr qu'une valeur ne se trouve pas dans le tableau. Lors de la recherche dichotomique, on limine la moiti des lments du tableau chaque excution de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement. La recherche dichotomique devient extrmement avantageuse pour la recherche dans de grands tableaux (tris) : L'avantage de la recherche dichotomique par rapport la recherche squentielle monte alors exponentiellement avec la grandeur du tableau trier. Page 97 sur 217

Module Langage de programmation structure


Exemple: Lors de la recherche dans un tableau de 1024 lments: - le pire des cas pour la recherche squentielle peut entraner 1024 excutions de la boucle. - le pire des cas pour la recherche dichotomique peut entraner 10 excutions de la boucle. Lors de la recherche dans un tableau de 1 048 576 lments: - le pire des cas pour la recherche squentielle peut entraner 1 048 576 excutions de la boucle. - le pire des cas pour la recherche dichotomique peut entraner 20 excutions de la boucle.

9. Exercice 9
#include <stdio.h> main() { /* Dclarations */ /* Les tableaux et leurs dimensions */ int A[50], B[50], FUS[100]; int N, M; int IA, IB, IFUS; /* indices courants */ /* Saisie des donnes */ printf("Dimension du tableau A (max.50) : "); scanf("%d", &N ); printf("Entrer les lments de A dans l'ordre croissant :\n"); for (IA=0; IA<N; IA++) { printf("Elment A[%d] : ", IA); scanf("%d", &A[IA]); } printf("Dimension du tableau B (max.50) : "); scanf("%d", &M ); printf("Entrer les lments de B dans l'ordre croissant :\n"); for (IB=0; IB<M; IB++) { printf("Elment B[%d] : ", IB); scanf("%d", &B[IB]); } /* Affichage des tableaux A et B */ printf("Tableau A :\n"); for (IA=0; IA<N; IA++) printf("%d ", A[IA]); printf("\n"); Page 98 sur 217

Module Langage de programmation structure


printf("Tableau B :\n"); for (IB=0; IB<M; IB++) printf("%d ", B[IB]); printf("\n"); /* Fusion des lments de A et B dans FUS */ /* de faon ce que FUS soit aussi tri. */ IA=0; IB=0; IFUS=0; while ((IA<N) && (IB<M)) if(A[IA]<B[IB]) { FUS[IFUS]=A[IA]; IFUS++; IA++; } else { FUS[IFUS]=B[IB]; IFUS++; IB++; } /* Si IA ou IB sont arrivs la fin de leur tableau, */ /* alors copier le reste de l'autre tableau. */ while (IA<N) { FUS[IFUS]=A[IA]; IFUS++; IA++; } while (IB<M) { FUS[IFUS]=B[IB]; IFUS++; IB++; } /* Edition du rsultat */ printf("Tableau FUS :\n"); for (IFUS=0; IFUS<N+M; IFUS++) printf("%d ", FUS[IFUS]); printf("\n"); return 0; }

10. Exercice 10
#include <stdio.h> main() { Page 99 sur 217

Module Langage de programmation structure


int int int int int int int POINTS[50]; /* tableau des points */ NOTES[7]; /* tableau des notes */ N; /* nombre d'lves */ I, IN; /* compteurs d'aide */ SOM; /* somme des points */ MAX, MIN; /* maximum, minimum de points */ MAXN; /* nombre de lignes du graphique */

/* Saisie des donnes */ printf("Entrez le nombre d'lves (max.50) : "); scanf("%d", &N); printf("Entrez les points des lves:\n"); for (I=0; I<N; I++) {printf("Elve %d:", I+1); scanf("%d", &POINTS[I]); } printf("\n"); /* Calcul et affichage du maximum et du minimum des points */ for (MAX=0, MIN=60, I=0; I<N; I++) {if (POINTS[I] > MAX) MAX=POINTS[I]; if (POINTS[I] < MIN) MIN=POINTS[I]; } printf("La note maximale est %d \n", MAX); printf("La note minimale est %d \n", MIN); /* Calcul et affichage de la moyenne des points */ for (SOM=0,I=0 ; I<N ; I++) SOM += POINTS[I]; printf("La moyenne des notes est %f \n", (float)SOM/N); /* Etablissement du tableau NOTES */ for (IN=0 ; IN<7 ; IN++) NOTES[IN] = 0; for (I=0; I<N; I++) NOTES[POINTS[I]/10]++; /* Recherche du maximum MAXN dans NOTES */ for (MAXN=0,IN=0 ; IN<7 ; IN++) if (NOTES[IN] > MAXN) MAXN = NOTES[IN]; /* Affichage du graphique de barreaux */ /* Reprsentation de MAXN lignes */ for (I=MAXN; I>0; I--) { printf("\n %2d >", I); for (IN=0; IN<7; IN++) { if (NOTES[IN]>=I) Page 100 sur 217

Module Langage de programmation structure


printf(" #######"); else printf(" "); }

/* Affichage du domaine des notes */ printf("\n +"); for (IN=0; IN<7; IN++) printf("-------+"); printf("\n I 0 - 9 I 10-19 I 20-29 " "I 30-39 I 40-49 I 50-59 I 60 I\n"); return 0; }

11. Exercice 11
#include <stdio.h> main() { /* Dclarations */ int T[50][50]; /* tableau donn */ int L, C; /* dimensions */ int I, J; /* indices courants */ long SOM; /* somme des lments - type long cause */ /* de la grandeur prvisible du rsultat. */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &L ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &C ); for (I=0; I<L; I++) for (J=0; J<C; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &T[I][J]); } /* Affichage du tableau */ printf("Tableau donn :\n"); for (I=0; I<L; I++) { for (J=0; J<C; J++) printf("%7d", T[I][J]); printf("\n"); } /* Calcul de la somme */ for (SOM=0, I=0; I<L; I++) for (J=0; J<C; J++) Page 101 sur 217

Module Langage de programmation structure


SOM += T[I][J]; /* Edition du rsultat */ printf("Somme des lments : %ld\n", SOM); return 0; }

12. Exercice 12
#include <stdio.h> main() { /* Dclarations */ int T[50][50]; /* tableau donn */ int L, C; /* dimensions */ int I, J; /* indices courants */ long SOM; /* somme des lments - type long cause */ /* de la grandeur prvisible des rsultats. */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &L ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &C ); for (I=0; I<L; I++) for (J=0; J<C; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &T[I][J]); } /* Affichage du tableau */ printf("Tableau donn :\n"); for (I=0; I<L; I++) { for (J=0; J<C; J++) printf("%7d", T[I][J]); printf("\n"); } /* Calcul et affichage de la somme des lignes */ for (I=0; I<L; I++) { for (SOM=0, J=0; J<C; J++) SOM += T[I][J]; printf("Somme - ligne %d : %ld\n",I,SOM); } /* Calcul et affichage de la somme des colonnes */ for (J=0; J<C; J++) { for (SOM=0, I=0; I<L; I++) SOM += T[I][J]; Page 102 sur 217

Module Langage de programmation structure


printf("Somme - colonne %d : %ld\n",J,SOM); } return 0; }

13. Exercice 13
#include <stdio.h> main() { /* Dclarations */ int M[10][10]; /* tableau 2 dimensions */ int V[100]; /* tableau 1 dimension */ int L, C; /* dimensions */ int I, J; /* indices courants */ /* Saisie des donnes */ printf("Nombre de lignes (max.10) : "); scanf("%d", &L ); printf("Nombre de colonnes (max.10) : "); scanf("%d", &C ); for (I=0; I<L; I++) for (J=0; J<C; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &M[I][J]); } /* Affichage du tableau 2-dim */ printf("Tableau donn :\n"); for (I=0; I<L; I++) { for (J=0; J<C; J++) printf("%7d", M[I][J]); printf("\n"); } /* Transfer des lments ligne par ligne */ for (I=0; I<L; I++) for (J=0; J<C; J++) V[I*C+J] = M[I][J]; /* Affichage du tableau 1-dim */ printf("Tableau rsultat : "); for (I=0; I<L*C; I++) printf("%d ", V[I]); printf("\n"); return 0; }

Page 103 sur 217

Module Langage de programmation structure


14. Exercice 14
#include <stdio.h> #include <stdlib.h> int main () { typedef int mat[3][3];//3 lignes 3 colonnes mat A; int compt=0; printf("Entrez les 9 valeurs de la matrice A:"); //lecture de A et comptage de 0: for(int i=0;i<=2;i++) for(int j=0;j<=2;j++) { scanf("%d",&A[i][j]); if (A[i][j]==0) //le symbole d'galit == ne pas confondre avec l'affectation = compt++; }//fin de boucle printf("Le nombre de 0 de la matrice A est : %d\n",compt); system("pause"); return 0; }

15. Exercice 15
#include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice carre */ int N; /* dimension de la matrice carre */ int I, J; /* indices courants */ /* Saisie des donnes */ printf("Dimension de la matrice carre (max.50) : "); scanf("%d", &N); Page 104 sur 217

Module Langage de programmation structure


for (I=0; I<N; I++) for (J=0; J<N; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } /* Affichage de la matrice */ printf("Matrice donne :\n"); for (I=0; I<N; I++) { for (J=0; J<N; J++) printf("%7d", A[I][J]); printf("\n"); } /* Mise zro de la diagonale principale */ for (I=0; I<N; I++) A[I][I]=0; /* Edition du rsultat */ printf("Matrice rsultat :\n"); for (I=0; I<N; I++) { for (J=0; J<N; J++) printf("%7d", A[I][J]); printf("\n"); } return 0; }

16. Exercice 16
#include <stdio.h> main() { /* Dclarations */ int U[50][50]; /* matrice unitaire */ int N; /* dimension de la matrice unitaire */ int I, J; /* indices courants */ /* Saisie des donnes */ printf("Dimension de la matrice carre (max.50) : "); scanf("%d", &N); /* Construction de la matrice carre unitaire */ for (I=0; I<N; I++) for (J=0; J<N; J++) if (I==J) U[I][J]=1; Page 105 sur 217

Module Langage de programmation structure


else U[I][J]=0; /* Edition du rsultat */ printf("Matrice unitaire de dimension %d :\n", N); for (I=0; I<N; I++) { for (J=0; J<N; J++) printf("%7d", U[I][J]); printf("\n"); } return 0; } Remarque: L'opration: if (I==J) U[I][J]=1; else U[I][J]=0; peut tre simplifie par: U[I][J] = (I==J);

17. Exercice 17
a) La matrice transpose sera mmorise dans une deuxime matrice B qui sera ensuite affiche. #include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice initiale */ int B[50][50]; /* matrice rsultat */ int N, M; /* dimensions des matrices */ int I, J; /* indices courants */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); for (I=0; I<N; I++) Page 106 sur 217

Module Langage de programmation structure


for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } /* Affichage de la matrice */ printf("Matrice donne :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } /* Affectation de la matrice transpose B */ for (I=0; I<N; I++) for (J=0; J<M; J++) B[J][I]=A[I][J]; /* Edition du rsultat */ /* Attention: maintenant le rle de N et M est invers. */ printf("Matrice rsultat :\n"); for (I=0; I<M; I++) { for (J=0; J<N; J++) printf("%7d", B[I][J]); printf("\n"); } return 0; } b) La matrice A sera transpose par permutation des lments. #include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice donne */ int N, M; /* dimensions de la matrice */ int I, J; /* indices courants */ int AIDE; /* pour la permutation */ int DMAX; /* la plus grande des deux dimensions */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); for (I=0; I<N; I++) for (J=0; J<M; J++) { Page 107 sur 217

Module Langage de programmation structure


printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } /* Affichage de la matrice */ printf("Matrice donne :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } /* Transposition de la matrice A par permutation des */ /* lments [I][J] gauche de la diagonale principale */ /* avec les lments [J][I] droite de la diagonale. */ DMAX = (N>M) ? N : M; for (I=0; I<DMAX; I++) for (J=0; J<I; J++) { AIDE = A[I][J]; A[I][J] = A[J][I]; A[J][I] = AIDE; } /* Edition du rsultat */ /* Attention: maintenant le rle de N et M est invers. */ printf("Matrice rsultat :\n"); for (I=0; I<M; I++) { for (J=0; J<N; J++) printf("%7d", A[I][J]); printf("\n"); } return 0; }

18. Exercice 18
a) Le rsultat de la multiplication sera mmoris dans une deuxime matrice A qui sera ensuite affiche. #include <stdio.h> main() { /* Dclarations */ float A[50][50]; /* matrice donne */ float B[50][50]; /* matrice rsultat */ int N, M; /* dimensions des matrices */ int I, J; /* indices courants */ float X; /* multiplicateur */ Page 108 sur 217

Module Langage de programmation structure


/* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%f", &A[I][J]); } printf("Multiplicateur X : "); scanf("%f", &X ); /* Affichage de la matrice */ printf("Matrice donne :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%10.2f", A[I][J]); printf("\n"); } /* Affectation du rsultat de la multiplication B */ for (I=0; I<N; I++) for (J=0; J<M; J++) B[I][J] = X*A[I][J]; /* Edition du rsultat */ printf("Matrice rsultat :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%10.2f", B[I][J]); printf("\n"); } return 0; } b) Les lments de la matrice A seront multiplis par X. #include <stdio.h> main() { /* Dclarations */ float A[50][50]; /* matrice donne */ int N, M; /* dimensions de la matrice */ int I, J; /* indices courants */ float X; /* multiplicateur */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); Page 109 sur 217

Module Langage de programmation structure


scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%f", &A[I][J]); } printf("Multiplicateur X : "); scanf("%f", &X); /* Affichage de la matrice */ printf("Matrice donne :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%10.2f", A[I][J]); printf("\n"); } /* Multiplication des lments de A par X */ for (I=0; I<N; I++) for (J=0; J<M; J++) A[I][J] *= X; /* Edition du rsultat */ printf("Matrice rsultat :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%10.2f", A[I][J]); printf("\n"); } return 0; }

19. Exercice 19
a) Le rsultat de l'addition sera mmoris dans une troisime matrice C qui sera ensuite affiche. #include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice donne */ int B[50][50]; /* matrice donne */ int C[50][50]; /* matrice rsultat */ int N, M; /* dimensions des matrices */ int I, J; /* indices courants */ Page 110 sur 217

Module Langage de programmation structure

/* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); printf("*** Matrice A ***\n"); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } printf("*** Matrice B ***\n"); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &B[I][J]); } /* Affichage des matrices */ printf("Matrice donne A :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } printf("Matrice donne B :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", B[I][J]); printf("\n"); } /* Affectation du rsultat de l'addition C */ for (I=0; I<N; I++) for (J=0; J<M; J++) C[I][J] = A[I][J]+B[I][J]; /* Edition du rsultat */ printf("Matrice rsultat C :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", C[I][J]); printf("\n"); } return 0; Page 111 sur 217

Module Langage de programmation structure


} b) La matrice B est ajoute A. #include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice donne et rsultat */ int B[50][50]; /* matrice donne */ int N, M; /* dimensions des matrices */ int I, J; /* indices courants */ /* Saisie des donnes */ printf("Nombre de lignes (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes (max.50) : "); scanf("%d", &M ); printf("*** Matrice A ***\n"); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } printf("*** Matrice B ***\n"); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &B[I][J]); } /* Affichage des matrices */ printf("Matrice donne A :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } printf("Matrice donne B :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", B[I][J]); printf("\n"); } /* Addition de B A */ Page 112 sur 217

Module Langage de programmation structure


for (I=0; I<N; I++) for (J=0; J<M; J++) A[I][J] += B[I][J]; /* Edition du rsultat */ printf("Matrice rsultat A :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } return 0; }

20. Exercice 20
#include <stdio.h> main() { /* Dclarations */ int A[50][50]; /* matrice donne */ int B[50][50]; /* matrice donne */ int C[50][50]; /* matrice rsultat */ int N, M, P; /* dimensions des matrices */ int I, J, K; /* indices courants */ /* Saisie des donnes */ printf("*** Matrice A ***\n"); printf("Nombre de lignes de A (max.50) : "); scanf("%d", &N ); printf("Nombre de colonnes de A (max.50) : "); scanf("%d", &M ); for (I=0; I<N; I++) for (J=0; J<M; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &A[I][J]); } printf("*** Matrice B ***\n"); printf("Nombre de lignes de B : %d\n", M); printf("Nombre de colonnes de B (max.50) : "); scanf("%d", &P ); for (I=0; I<M; I++) for (J=0; J<P; J++) { printf("Elment[%d][%d] : ",I,J); scanf("%d", &B[I][J]); } /* Affichage des matrices */ Page 113 sur 217

Module Langage de programmation structure


printf("Matrice donne A :\n"); for (I=0; I<N; I++) { for (J=0; J<M; J++) printf("%7d", A[I][J]); printf("\n"); } printf("Matrice donne B :\n"); for (I=0; I<M; I++) { for (J=0; J<P; J++) printf("%7d", B[I][J]); printf("\n"); } /* Affectation du rsultat de la multiplication C */ for (I=0; I<N; I++) for (J=0; J<P; J++) { C[I][J]=0; for (K=0; K<M; K++) C[I][J] += A[I][K]*B[K][J]; } /* Edition du rsultat */ printf("Matrice rsultat C :\n"); for (I=0; I<N; I++) { for (J=0; J<P; J++) printf("%7d", C[I][J]); printf("\n"); } return 0; }

21. Exercice 21
#include <stdio.h> main() { /* Dclarations */ int P[14][14]; /* matrice rsultat */ int N; /* degr du triangle */ int I, J; /* indices courants */ /* Saisie des donnes */ do { printf("Entrez le degr N du triangle (max.13) : "); scanf("%d", &N); } while (N>13||N<0); /* Construction des lignes 0 N du triangle: */ /* Calcul des composantes du triangle jusqu' */ Page 114 sur 217

Module Langage de programmation structure


/* la diagonale principale. */ for (I=0; I<=N; I++) { P[I][I]=1; P[I][0]=1; for (J=1; J<I; J++) P[I][J] = P[I-1][J] + P[I-1][J-1]; } /* Edition du rsultat */ printf("Triangle de Pascal de degr %d :\n", N); for (I=0; I<=N; I++) { printf(" N=%2d", I); for (J=0; J<=I; J++) if (P[I][J]) printf("%5d", P[I][J]); printf("\n"); } return 0; }

X.
A.

Les chanes de caractres


Introduction

Il n'existe pas de type spcial chane ou string en C. Une chane de caractres est traite comme un tableau une dimension de caractres (vecteur de caractres). Il existe quand mme des notations particulires et une bonne quantit de fonctions spciales pour le traitement de tableaux de caractres.

1. Dclaration et mmorisation
a) Dclaration
La dclaration de chanes de caractres en C est la suivante: char <NomVariable> [<Longueur>]; Exemple: char NOM [20]; char PRENOM [20]; char PHRASE [300];

b) Espace rserv
Lors de la dclaration, nous devons indiquer l'espace rserver en mmoire pour le stockage de la chane.

Page 115 sur 217

Module Langage de programmation structure


La reprsentation interne d'une chane de caractres est termine par le symbole '\0' (NUL). Ainsi, pour un texte de n caractres, nous devons prvoir n+1 octets.

c) Mmorisation
Le nom d'une chane est le reprsentant de l'adresse du premier caractre de la chane. Pour mmoriser une variable qui doit tre capable de contenir un texte de N caractres, nous avons besoin de N+1 octets en mmoire: Exemple : char TXT[10] = "BONJOUR !";

2. Les chanes de caractres constantes


Les chanes de caractres constantes sont indiques entre guillemets. La chane de caractres vide est alors: "" Dans les chanes de caractres, nous pouvons d'chappement dfinies comme caractres constants: utiliser toutes les squences

"Ce \ntexte \nsera rparti sur 3 lignes." Le symbole " peut tre reprsent l'intrieur d'une chane par la squence d'chappement \": "Affichage de \"guillemets\" \n"

Observation Pour la mmorisation de la chane de caractres "Hello", C a besoin de six (!!) octets. 'x' est un caractre constant, qui a une valeur numrique: P.ex: 'x' a la valeur 120 dans le code ASCII. "x" est un tableau de caractres qui contient deux caractres: la lettre 'x' et le caractre NUL: '\0' 'x' est cod dans un octet "x" est cod dans deux octets

Page 116 sur 217

Module Langage de programmation structure


3. Initialisation de chanes de caractres
En gnral, les tableaux sont initialiss par l'indication de la liste des lments du tableau entre accolades: char CHAINE[] = {'H','e','l','l','o','\0'}; Pour le cas spcial des tableaux de caractres, nous pouvons utiliser une initialisation plus confortable en indiquant simplement une chane de caractre constante: char CHAINE[] = "Hello"; Lors de l'initialisation par [], l'ordinateur rserve automatiquement le nombre d'octets ncessaires pour la chane, c.--d.: le nombre de caractres + 1 (ici: 6 octets). Nous pouvons aussi indiquer explicitement le nombre d'octets rserver, si celui-ci est suprieur ou gal la longueur de la chane d'initialisation. Exemple :

Page 117 sur 217

Module Langage de programmation structure


4. Exercice 1
Lesquelles des chanes suivantes sont initialises correctement ? Corrigez les dclarations fausses et indiquez pour chaque chane de caractres le nombre d'octets qui sera rserv en mmoire. a) b) c) d) e) f) g) h) char a[] = "un\ndeux\ntrois\n"; char b[12] = "un deux trois"; char c[] = 'abcdefg'; char d[10] = 'x'; char e[5] = "cinq"; char f[] = "Cette " "phrase" "est coupe"; char g[2] = {'a', '\0'}; char h[4] = {'a', 'b', 'c'};

5. Accs aux lments d'une chane


L'accs un lment d'une chane de caractres peut se faire de la mme faon que l'accs un lment d'un tableau. En dclarant une chane par: char A[6]; Nous avons dfini un tableau A avec six lments, auxquels on peut accder par: A[0], A[1], ... , A[5] Exemple

6. Prcdence alphabtique et lexicographique


a) Prcdence alphabtique des caractres
La prcdence des caractres dans l'alphabet d'une machine est dpendante du code de caractres utilis. Pour le code ASCII, nous pouvons constater l'ordre suivant: . . . ,0,1,2, ... ,9, . . . ,A,B,C, ... ,Z, . . . ,a,b,c, ... ,z, . . . Les symboles spciaux (' ,+ ,- ,/ ,{ ,] , ...) et les lettres accentues ( , , , , ...) se trouvent rpartis autour des trois grands groupes de caractres (chiffres, majuscules, minuscules). Leur prcdence ne correspond aucune rgle d'ordre spcifique.

Page 118 sur 217

Module Langage de programmation structure


De la prcdence alphabtique des caractres, on peut dduire une relation de prcdence 'est infrieur ' sur l'ensemble des caractres. Ainsi, on peut dire que '0' est infrieur 'Z' et noter '0' < 'Z' Car dans l'alphabet de la machine, le code du caractre '0' (ASCII: 48) est infrieur au code du caractre 'Z' (ASCII: 90).

b) Prcdence lexicographique des chanes de caractres


En nous basant sur cette relation de prcdence alphabtique des caractres, nous pouvons dfinir une prcdence lexicographique pour les chanes de caractres. Cette relation de prcdence suit l'<<ordre du dictionnaire>> et est dfinie de faon rcurrente: a) La chane vide "" prcde lexicographiquement toutes les autres chanes. b) La chane A = "a1a2a ... ap" (p caractres) prcde lexicographiquement la chane B = "b 1b2 ... bm" (m caractres) si l'une des deux conditions suivantes est remplie: 1) 'a1' < 'b1' 2) 'a1' = 'b1' et "a2a3 ... ap" prcde lexicographiquement "b 2b3 ... bm" Exemples "ABC" prcde "BCD" car 'A'<'B' "ABC" prcde "B" car 'A'<'B' "Abc" prcde "abc" car 'A'<'a' "ab" prcde "abcd" car "" prcde "cd" " ab" prcde "ab" car ' '<'a' (le code ASCII de ' ' est 32, et le code ASCII de 'a' est 97) En tenant compte de l'ordre alphabtique des caractres, on peut contrler le type du caractre (chiffre, majuscule, minuscule). Exemples if (C>='0' && C<='9') printf("Chiffre\n", C); if (C>='A' && C<='Z') printf("Majuscule\n", C); if (C>='a' && C<='z') printf("Minuscule\n", C); Il est facile, de convertir des lettres majuscules dans des minuscules: if (C>='A' && C<='Z') C = C-'A'+'a'; ou vice-versa: if (C>='a' && C<='z') C = C-'a'+'A';

B.

Travailler avec des chanes de caractres


Page 119 sur 217

Les bibliothques de fonctions de C contiennent une srie de fonctions spciales pour le traitement de chanes de caractres.

Module Langage de programmation structure


1. Les fonctions de <stdio.h>
Comme nous l'avons dj vu, la bibliothque <stdio> nous offre des fonctions qui effectuent l'entre et la sortie des donnes. A ct des fonctions printf et scanf que nous connaissons dj, nous y trouvons les deux fonctions puts et gets, spcialement conues pour l'criture et la lecture de chanes de caractres.

a) Affichage de chanes de caractres


printf avec le spcificateur de format %s permet d'intgrer une chane de caractres dans une phrase. En plus, le spcificateur %s permet l'indication de la largeur minimale du champ d'affichage. Dans ce champ, les donnes sont justifies droite. Si on indique une largeur minimale ngative, la chane sera justifie gauche. Un nombre suivant un point indique la largeur maximale pour l'affichage. Exemples char NOM[] = "hello, world"; printf(":%s:", NOM); printf(":%5s:", NOM); printf(":%15s:", NOM); printf(":%-15s:", NOM); printf(":%.5s:", NOM); -> :hello, world: -> :hello, world: -> : hello, world: : -> :hello, world -> :hello:

puts est idale pour crire une chane constante ou le contenu d'une variable dans une ligne isole. Syntaxe: puts( <Chane> )

En effet : puts crit la chane de caractres dsigne par <Chane> sur stdout et provoque un retour la ligne. En pratique, puts(TXT); est quivalent printf("%s\n",TXT); Exemples char TEXTE[] = "Voici une premire ligne."; puts(TEXTE); puts("Voici une deuxime ligne.");

b) Lecture de chanes de caractres


scanf avec le spcificateur %s permet de lire un mot isol l'intrieur d'une suite de donnes du mme ou d'un autre type. En effet: scanf avec le spcificateur %s lit un mot du fichier d'entre standard stdin et le mmorise l'adresse qui est associe %s. Exemple char LIEU[25]; int JOUR, MOIS, ANNEE; printf("Entrez lieu et date de naissance : \n"); Page 120 sur 217

Module Langage de programmation structure


scanf("%s %d %d %d", LIEU, &JOUR, &MOIS, &ANNEE); Remarques importantes - La fonction scanf a besoin des adresses de ses arguments: Les noms des variables numriques (int, char, long, float, ...) doivent tre marqus par le symbole '&'. Comme le nom d'une chane de caractres est le reprsentant de l'adresse du premier caractre de la chane, il ne doit pas tre prcd de l'oprateur adresse '&' !

- La fonction scanf avec plusieurs arguments prsuppose que l'utilisateur connaisse exactement le nombre et l'ordre des donnes introduire! Ainsi, l'utilisation de scanf pour la lecture de chanes de caractres est seulement conseille si on est forc de lire un nombre fix de mots en une fois. gets est idal pour lire une ou plusieurs lignes de texte (p.ex. des phrases) termines par un retour la ligne. Syntaxe : gets ( <Chane > )

En effet: gets lit une ligne de de caractres de stdin et la copie l'adresse indique par <Chane>. Le retour la ligne final est remplac par le symbole de fin de chane \0' Exemple int MAXI = 1000; char LIGNE[MAXI]; gets(LIGNE);

c) Exercice 2
Ecrire un programme qui lit 5 mots, spars par des espaces et qui les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les mots sont mmoriss dans 5 variables M1, ... ,M5. Exemple voici une petite phrase ! ! phrase petite une voici

d) Exercice 3
Ecrire un programme qui lit une ligne de texte (ne dpassant pas 200 caractres) la mmorise dans une variable TXT et affiche ensuite: a) la longueur L de la chane. b) le nombre de 'e' contenus dans le texte. c) toute variable TXT. la phrase rebours, rebours, sans aprs changer avoir le contenu de la des

d) toute la phrase caractres dans TXT:

invers

l'ordre

voici une petite phrase ! ! esarhp etitep enu iciov

Page 121 sur 217

Module Langage de programmation structure


e) Exercice 4
Ecrire un programme qui lit un texte TXT (de moins de 200 caractres) et qui enlve toutes les apparitions du charactre 'e' en tassant les lments restants. Les modifications se feront dans la mme variable TXT. Exemple: Cette ligne contient quelques lettres e. Ctt lign contint qulqus lttrs .

2. Les fonctions de <string.h>


La bibliothque <string> fournit une multitude de fonctions pratiques pour le traitement de chanes de caractres. Voici une brve description des fonctions les plus frquemment utilises. Dans le tableau suivant, <n> reprsente un nombre du type int. Les symboles <s> et <t> peuvent tre remplacs par : Une chane de caractres constante Le nom d'une variable dclare comme tableau de char Un pointeur sur char (voir chapitre des pointeurs) Description fournit la longueur de la chane sans compter le '\0' final copie <t> vers <s> ajoute <t> la fin de <s> compare <s> et <t> lexicographiquement et fournit un rsultat: ngatif si <s> prcde <t> zro si <s> est gal <t> positif si <s> suit <t> copie au plus <n> caractres de <t> vers <s> ajoute au plus <n> caractres de <t> la fin de <s>

Fonction strlen(<s>) strcpy(<s>, <t>) strcat(<s>, <t>) strcmp(<s>, <t>)

strncpy(<s>, <t>, <n>) strncat(<s>, <t>, <n>) Remarques

Comme le nom d'une chane de caractres reprsente une adresse fixe en mmoire, on ne peut pas 'affecter' une autre chane au nom d'un tableau:

Il faut bien copier la respectivement strncpy: strcpy(A, "Hello");

chane caractre par caractre ou

utiliser la

fonction strcpy

La concatnation de chanes de caractres en C ne se fait pas par le symbole '+' comme en langage algorithmique ou en Pascal. Il faut ou bien copier la deuxime chane caractre par caractre ou bien utiliser la fonction strcat ou strncat. Page 122 sur 217

Module Langage de programmation structure


a) Exercice 5
Ecrire un programme qui demande l'introduction du nom et du prnom de l'utilisateur et qui affiche alors la longueur totale du nom sans compter les espaces. Employer la fonction strlen. Exemple: Introduisez votre nom et votre prnom: Mickey Mouse Bonjour Mickey Mouse ! Votre nom est compos de 11 lettres.

b) Exercice 6
Ecrire un programme qui lit deux chanes de caractres CH1 et CH2, les compare lexicographiquement et affiche le rsultat: Exemple: Introduisez la premire chane: ABC Introduisez la deuxime chane: abc "ABC" prcde "abc"

c) Exercice 7
Ecrire un programme qui lit deux chanes de caractres CH1 et CH2 et qui copie la premire moiti de CH1 et la premire moiti de CH2 dans une troisime chane CH3. Afficher le rsultat. a) Utiliser les fonctions spciales de <string>. b) Utiliser uniquement les fonctions gets et puts.

d) Exercice 8
Ecrire un programme qui lit un verbe rgulier en "er" au clavier et qui en affiche la conjugaison au prsent de l'indicatif de ce verbe. Contrlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. Utiliser les fonctions gets, puts, strcat et strlen. Exemple: Verbe : fter je fte tu ftes il fte nous ftons vous ftez ils ftent

Page 123 sur 217

Module Langage de programmation structure


3. Les fonctions de <stdlib.h>
La bibliothque <stdlib> contient des dclarations de fonctions pour la conversion de nombres en chanes de caractres et vice-versa.

a) Conversion de Chane en Nombre


Dans Les trois fonctions dfinies ci-dessous, Le symbole <s> peut tre remplac par : une chane de caractres constante le nom d'une variable dclare comme tableau de char un pointeur sur char (voir chapitre des pointeurs)

atoi(<s>) atol(<s>) atof(<s>)

retourne la valeur numrique reprsente par <s> comme int retourne la valeur numrique reprsente par <s> comme long retourne la valeur numrique reprsente par <s> comme double

Rgles gnrales pour la conversion: Les espaces au dbut d'une chane sont ignors La conversion s'arrte au premier caractre non convertible Pour une chane non convertible, les fonctions retournent zro

b) Exercice 9
Soient les instructions: char STR[200]; puts("Entrez un nombre :"); gets(STR); printf("Entre = %s \n", STR); printf("integer = %d \n", atoi(STR)); printf("long = %ld \n", atol(STR)); printf("double = %f \n", atof(STR)); Quelles sont les valeurs affiches si on entre les chanes de caractres suivantes: a) b) c) d) e) f) g) h) i) 123 -123 - 123 123.45 12E3 1234f5 -1234567 123e-02 -0,1234 Page 124 sur 217

Module Langage de programmation structure


c) Conversion de Nombre en Chane
On utilise les fonctions suivantes: Avec : <n_int> <n_long> <s> <b> est un nombre du type int est un nombre du type long est une chane de caractres est la base pour la conversion (2 ... 36) itoa (<n_int>, <s>, <b>) ltoa (<n_long>, <s>, <b>) ultoa (<n_uns_long>, <s>, <b>)

<n_uns_long> est un nombre du type unsigned long

d) Exercice 10
Ecrire un programme qui permet de convertir un nombre en base 2, 8 et 16 en utilisant la fonction ltoa

4. Les fonctions de <ctype.h>


Les fonctions de <ctype> servent classifier et convertir des caractres

a) Les fonctions de classification


Les fonctions de classification suivantes fournissent un rsultat du type int diffrent de zro, si la condition respective est remplie, sinon zro. (<c> est un caractre) La fonction isupper(<c>) islower(<c>) isdigit(<c>) isalpha(<c>) isalnum(<c>) isxdigit(<c>) isspace(<c>) retourne une valeur diffrente de zro si <c> est une majuscule ('A'...'Z') si <c> est une minuscule ('a'...'z') si <c> est un chiffre dcimal ('0'...'9') si islower(<c>) ou isupper(<c>) si isalpha(<c>) ou isdigit(<c>) si <c> est un chiffre hexadcimal ('0'...'9' ou 'A'...'F' ou 'a'...'f') si <c> est un signe d'espacement (' ', '\t', '\n')

b) Les fonctions de conversion


tolower(<c>) retourne <c> converti en minuscule si <c> est une majuscule toupper(<c>) retourne <c> converti en majuscule si <c> est une minuscule

Page 125 sur 217

Module Langage de programmation structure


C.Tableaux de chanes de caractres
Souvent, il est ncessaire de mmoriser une suite de mots ou de phrases dans des variables. Il est alors pratique de crer un tableau de chanes de caractres, ce qui allgera les dclarations des variables et simplifiera l'accs aux diffrents mots (ou phrases).

1. Dclaration, initialisation et mmorisation


Un tableau de chanes de caractres correspond un tableau deux dimensions du type char, o chaque ligne contient une chane de caractres.

a) Dclaration
La dclaration char JOUR[7][9]; Rserve l'espace en mmoire pour 7 mots contenant 9 caractres (dont 8 caractres significatifs).

b) Initialisation
Lors de la dclaration il est possible d'initialiser toutes les composantes du tableau par des chanes de caractres constantes: char JOUR[7][9]= {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"};

c) Mmorisation
Les tableaux de chanes sont mmoriss ligne par ligne. La variable JOUR aura donc besoin de 7*9*1 = 63 octets en mmoire Page 126 sur 217

Module Langage de programmation structure


2. Accs aux diffrentes composantes
a) Accs aux chanes
Il est possible d'accder aux diffrentes chanes de caractres d'un tableau, en indiquant simplement la ligne correspondante. Exemple: L'excution des trois instructions suivantes: char JOUR[7][9]= {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"}; int I = 2; printf("Aujourd'hui, c'est %s !\n", JOUR[I]); Affichera la phrase: Aujourd'hui, c'est mercredi ! Affectation Des expressions comme JOUR[I] reprsentent l'adresse du premier lment d'une chane de caractres. N'essayez donc pas de 'modifier' une telle adresse par une affectation directe !

L'attribution d'une chane de caractres une composante d'un tableau de chanes se fait en gnral l'aide de la fonction strcpy Exemple: La commande strcpy(JOUR[4], "Friday"); changera le contenu de la 5e composante du tableau JOUR de "vendredi" en "Friday".

b) Accs aux caractres


Evidemment, il existe toujours la possibilit d'accder directement aux diffrents caractres qui composent les mots du tableau. Exemple L'instruction for(I=0; I<7; I++) printf("%c ", JOUR[I][0]); Va afficher les premires lettres des jours de la semaine: l m m j v s d

Page 127 sur 217

Module Langage de programmation structure


c) Exercice 11
Ecrire un programme qui lit 10 mots et les mmorise dans un tableau de chanes de caractres. Trier les 10 mots lexicographiquement en utilisant les fonctions strcmp et strcpy. Afficher le tableau tri. Utilisez la mthode de tri par slection

d) Exercice 12
Ecrire un programme qui lit un nombre entre 1 et 7 et qui affiche le nom du jour de la semaine correspondant: "lundi" "mardi" ... pour 1 pour 2 ...

"dimanche" pour 7 Utiliser le premier lment du tableau pour mmoriser un petit message d'erreur.

e) Exercice 13
Ecrire un programme qui lit 5 mots, spars par des espaces et qui les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les mots sont mmoriss dans un tableau de chanes de caractres. Exemple voici une petite phrase ! ! phrase petite une voici

D.

Exercices de synthse

1. Exercice 14
Ecrire un programme qui lit une chane de caractres CH et qui convertit toutes les majuscules dans des minuscules et vice-versa. (sans utiliser les fonctions de conversion) Le rsultat sera mmoris dans la mme variable CH et affich aprs la conversion.

2. Exercice 15
Ecrire un programme qui supprime la premire occurrence d'une chane de caractres OBJ dans une chane de caractres SUJ. Exemples: PHON ALPHONSE EI T PIERRE HELLO ALSE PIERRE HELLO

TOTALEMENT OTALEMENT

Page 128 sur 217

Module Langage de programmation structure


3. Exercice 16
Ecrire un programme qui remplace toutes les occurrences d'une chane de caractres CH1 par la chane CH2 dans une chane de caractres SUJ. Utiliser une chane de sauvegarde FIN pendant le remplacement. Exemples: PHON OY AN T L Y ALPHONSE ALOYSE BONTONTE HELLO HEO ONT BANANE TTT HELLO HELLO

TOTALEMENT YOYALEMENY

E.Correction des exercices


1. Exercice 1
a) char a[] = "un\ndeux\ntrois\n"; Dclaration correcte Espace: 15 octets b) char b[12] = "un deux trois"; Dclaration incorrecte: la chane d'initialisation dpasse le bloc de mmoire rserv. Correction: char b[14] = "un deux trois"; ou mieux: char b[] = "un deux trois"; Espace: 14 octets c) char c[] = 'abcdefg'; Dclaration incorrecte: Les symboles '' encadrent des caractres; pour initialiser avec une chane de caractres, il faut utiliser les guillemets (ou indiquer une liste de caractres). Correction: char c[] = "abcdefg"; Espace: 8 octets d) char d[10] = 'x'; Dclaration incorrecte: Il faut utiliser une liste de caractres ou une chane pour l'initialisation Correction: char d[10] = {'x', '\0'} ou mieux: char d[10] = "x"; Espace: 2 octets e) char e[5] = "cinq"; Dclaration correcte Espace: 5 octets f) char f[] = "Cette " "phrase" "est coupe"; Dclaration correcte Espace: 23 octets Page 129 sur 217

Module Langage de programmation structure


g) char g[2] = {'a', '\0'}; Dclaration correcte Espace: 2 octets h) char h[4] = {'a', 'b', 'c'}; Dclaration incorrecte: Dans une liste de caractres, il faut aussi indiquer le symbole de fin de chane. Correction: char h[4] = {'a', 'b', 'c', '\0'}; Espace: 4 octets

2. Exercice 2
#include <stdio.h> main() { char M1[30], M2[30], M3[30], M4[30], M5[30]; printf("Entrez 5 mots, spars par des espaces :\n"); scanf ("%s %s %s %s %s", M1, M2, M3, M4, M5); printf("%s %s %s %s %s\n",M5, M4, M3, M2, M1); return 0; }

3. Exercice 3
#include <stdio.h> main() { /* Dclarations */ char TXT[201]; /* chane donne */ int I,J; /* indices courants */ int L; /* longueur de la chane */ int C; /* compteur des lettres 'e' */ int AIDE; /* pour l'change des caractres */ /* Saisie des donnes */ printf("Entrez une ligne de texte (max.200 caractres) :\n"); gets(TXT); /* L'utilisation de scanf est impossible pour */ /* lire une phrase contenant un nombre variable de mots. */ /* a) Compter les caractres */ /* La marque de fin de chane '\0' est */ /* utilise comme condition d'arrt. */ for (L=0; TXT[L]; L++) ; printf("Le texte est compos de %d caractres.\n",L); /* b) Compter les lettres 'e' dans le texte */ C=0; Page 130 sur 217

Module Langage de programmation structure


for (I=0; TXT[I]; I++) if (TXT[I]=='e') C++; printf("Le texte contient %d lettres \'e\'.\n",C); /* c) Afficher la phrase l'envers */ for (I=L-1; I>=0; I--) putchar(TXT[I]); /* ou printf("%c",TXT[I]); */ putchar('\n'); /* ou printf("\n"); */ /* d) Inverser l'ordre des caractres */ for (I=0,J=L-1 ; I<J ; I++,J--) { AIDE=TXT[I]; TXT[I]=TXT[J]; TXT[J]=AIDE; } puts(TXT); /* ou printf("%s\n",TXT); */ return 0; }

4. Exercice 4
#include <stdio.h> main() { /* Dclarations */ char TXT[201]; /* chane donne int I,J; /* indices courants */

*/

/* Saisie des donnes */ printf("Entrez une ligne de texte (max.200 caractres) :\n"); gets(TXT); /* Eliminer les lettres 'e' et comprimer : */ /* Copier les caractres de I vers J et incrmenter J */ /* seulement pour les caractres diffrents de 'e'. */ for (J=0,I=0 ; TXT[I] ; I++) { TXT[J] = TXT[I]; if (TXT[I] != 'e') J++; } /* Terminer la chane !! */ TXT[J]='\0'; /* Edition du rsultat */ puts(TXT); return 0; }

Page 131 sur 217

Module Langage de programmation structure


5. Exercice 5
#include <stdio.h> #include <string.h> main() { char NOM[40], PRENOM[40]; printf("Introduisez votre nom et votre prnom: \n"); scanf("%s %s", NOM, PRENOM); printf("\nBonjour %s %s !\n", NOM, PRENOM); printf("Votre nom est compos de %d lettres.\n", strlen(NOM) + strlen(PRENOM)); /* ou bien printf("Votre nom est compos de %d lettres.\n", strlen(strcat(NOM,PRENOM))); */ return 0; }

6. Exercice 6
#include <stdlib.h> #include <string.h> main() { /* Dclarations */ char CH1[200], CH2[200]; /* chanes entres */ int RES; /* rsultat de la fonction strcmp */ printf("Introduisez la premire chane de caractres : "); gets(CH1); printf("Introduisez la deuxime chane de caractres : "); gets(CH2); /* Comparaison et affichage du rsultat */ RES = strcmp(CH1,CH2); if (RES<0) printf("\"%s\" prcde \"%s\"\n",CH1 ,CH2); else if (RES>0) printf("\"%s\" prcde \"%s\"\n",CH2 ,CH1); else printf("\"%s\" est gal \"%s\"\n",CH1, CH2); return 0; }

7. Exercice 7
a) Utiliser les fonctions spciales de <string>. Page 132 sur 217

Module Langage de programmation structure


#include <stdio.h> #include <string.h> main() { /* Dclarations */ char CH1[100], CH2[100]; /* chanes donnes */ char CH3[100]=""; /* chane rsultat */ /* Saisie des donnes */ printf("Introduisez la premire chane de caractres : "); gets(CH1); printf("Introduisez la deuxime chane de caractres : "); gets(CH2); /* Traitements */ strncpy(CH3, CH1, strlen(CH1)/2); strncat(CH3, CH2, strlen(CH2)/2); /* Affichage du rsultat */ printf("Un demi \"%s\" plus un demi \"%s\" donne \"%s\"\n", CH1, CH2, CH3); return 0; } b) Utiliser uniquement les fonctions gets et puts. #include <stdio.h> main() { /* Dclarations */ char CH1[100], CH2[100]; /* chanes donnes */ char CH3[100]=""; /* chane rsultat */ int L1,L2; /* longueurs de CH1 et CH2 */ int I; /* indice courant dans CH1 et CH2 */ int J; /* indice courant dans CH3 */ /* Saisie des donnes */ puts("Introduisez la premire chane de caractres : "); gets(CH1); puts("Introduisez la deuxime chane de caractres : "); gets(CH2); /* Dtermination les longueurs de CH1 et CH2 */ for (L1=0; CH1[L1]; L1++) ; for (L2=0; CH2[L2]; L2++) ; /* Copier la premire moiti de CH1 vers CH3 */ for (I=0 ; I<(L1/2) ; I++) CH3[I]=CH1[I]; /* Copier la premire moiti de CH2 vers CH3 */ Page 133 sur 217

Module Langage de programmation structure


J=I; for (I=0 ; I<(L2/2) ; I++) { CH3[J]=CH2[I]; J++; } /* Terminer la chane CH3 */ CH3[J]='\0'; /* Affichage du rsultat */ puts("Chane rsultat : "); puts(CH3); return 0; }

8. Exercice 8
#include <stdio.h> #include <string.h> main() { /* Dclarations */ char VERB[20]; /* chane contenant le verbe */ char AFFI[30]; /* chane pour l'affichage */ int L; /* longueur de la chane */ /* Saisie des donnes */ printf("Verbe : "); gets(VERB); /* Contrler s'il s'agit d'un verbe en 'er' */ L=strlen(VERB); if ((VERB[L-2]!='e') || (VERB[L-1]!='r')) puts("\aCe n'est pas un verbe du premier groupe.!"); else { /* Couper la terminaison 'er'. */ VERB[L-2]='\0'; /* Conjuguer ... */ AFFI[0]='\0'; strcat(AFFI, "je "); strcat(AFFI, VERB); strcat(AFFI, "e"); puts(AFFI); ... AFFI[0]='\0'; strcat(AFFI, "ils "); Page 134 sur 217

Module Langage de programmation structure


strcat(AFFI, VERB); strcat(AFFI, "ent"); puts(AFFI); } return 0; }

9. Exercice 9

10. Exercice 10
#include <stdio.h> #include <stdlib.h> main() { long N; char STR[200]; puts("Entrez un nombre :"); scanf("%ld",&N); printf("Entre = %ld\n", N); printf("base 2 = %s\n", ltoa(N, STR, 2)); printf("base 8 = %s\n", ltoa(N, STR, 8)); printf("base 16 = %s\n", ltoa(N, STR, 16)); return 0; }

Page 135 sur 217

Module Langage de programmation structure


11. Exercice 11
#include <stdio.h> #include <string.h> main() { /* Dclarations */ char MOT[10][50]; /* tableau de 10 mots trier */ char AIDE[50]; /* chane d'aide pour la permutation */ int I; /* rang partir duquel MOT n'est pas tri */ int J; /* indice courant */ int PMOT; /* indique la position du prochain mot */ /* dans la suite lexicographique. */ /* Saisie des donnes */ for (J=0; J<10; J++) { printf("Mot %d : ", J); gets(MOT[J]); /* ou : scanf ("%s\n", MOT[J]); */ } /* Tri du tableau par slection directe du */ /* prochain mot dans la suite lexicographique. */ for (I=0; I<9; I++) { /* Recherche du prochain mot droite de A[I] */ PMOT=I; for (J=I+1; J<10; J++) if (strcmp(MOT[J], MOT[PMOT]) < 0) PMOT=J; /* Echange des mots l'aide de strcpy */ strcpy(AIDE, MOT[I]); strcpy(MOT[I], MOT[PMOT]); strcpy(MOT[PMOT], AIDE); } /* Edition du rsultat */ printf("Tableau tri lexicographiquement :\n"); for (J=0; J<10; J++) puts(MOT[J]); /* ou : printf("%s\n",MOT[J]); */ printf("\n"); return 0; }

12. Exercice 12
#include <stdio.h> main() { Page 136 sur 217

Module Langage de programmation structure


/* Dclarations */ int N; /* nombre entr */ char JOUR[8][9] = {"\aErreur!", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi","dimanche"}; /* Saisie du nombre */ printf("Entrez un nombre entre 1 et 7 : "); scanf("%d", &N); /* Affichage du rsultat - pour perfectionnistes */ if (N>0 && N<8) printf("Le %de%c jour de la semaine est %s.\n", N, (N==1)?'r':' ', JOUR[N]); else puts(JOUR[0]); return 0; }

13. Exercice 13
#include <stdio.h> main() { /* Dclarations */ char MOT[5][50]; /* tableau pour les 5 mots */ int I; /* indice courant */ /* Saisie des mots */ printf("Entrez 5 mots, spars par des espaces :\n"); /* Aprs le retour la ligne, scanf lit */ /* les 5 donnes la fois. */ for (I=0; I<5; I++) scanf("%s", MOT[I]); /* Affichage du rsultat */ for (I=4; I>=0; I--) printf("%s ", MOT[I]); printf("\n"); return 0; }

14. Exercice 14
#include <stdio.h> main() { /* Dclarations */ char CH[100]; /* chane convertir */ int I; /* indice courant */ /* Saisie de la chane */ Page 137 sur 217

Module Langage de programmation structure


printf("Entrez la chane convertir : "); gets(CH); /* Conversion de la chane */ for (I=0; CH[I]; I++) { if (CH[I]>='A' && CH[I]<='Z') CH[I] = CH[I]-'A'+'a'; else if (CH[I]>='a' && CH[I]<='z') CH[I] = CH[I]-'a'+'A'; } /* Affichage de la chane convertie */ printf("Chane convertie : %s\n", CH); return 0; }

15. Exercice 15
#include <stdio.h> main() { /* Dclarations */ char SUJ[100]; /* chane transformer */ char OBJ[100]; /* chane supprimer dans SUJ */ int I; /* indice courant dans SUJ */ int J; /* indice courant dans OBJ */ int TROUVE; /* indicateur logique qui prcise */ /* si la chane OBJ a t trouve */ /* Saisie des donnes */ printf("Introduisez la chane supprimer : "); gets(OBJ); printf("Introduisez la chane transformer : "); gets(SUJ); /* Recherche de OBJ dans SUJ */ TROUVE=0; for (I=0; SUJ[I] && !TROUVE; I++) /* Si la premire lettre est identique, */ if (SUJ[I]==OBJ[0]) { /* alors comparer le reste de la chane */ for (J=1; OBJ[J] && (OBJ[J]==SUJ[I+J]); J++) ; if (OBJ[J]=='\0') TROUVE=1; } /* Si la position de dpart de OBJ dans SUJ a t trouve */ /* alors dplacer le reste de SUJ cette position. */ if (TROUVE) { I--; Page 138 sur 217

Module Langage de programmation structure


/* Maintenant I indique la position de OBJ */ /* dans SUJ et J indique la longueur de OBJ */ for (; SUJ[I+J]; I++) SUJ[I]=SUJ[I+J]; SUJ[I]='\0'; } /* Affichage du rsultat */ printf("Chane rsultat : \"%s\"\n", SUJ); return 0; }

16. Exercice 16
#include <stdio.h> main() { /* Dclarations */ char SUJ[100]; /* chane transformer */ char CH1[100]; /* chane rechercher */ char CH2[100]; /* chane de remplacement */ char FIN[100]; /* chane de sauvegarde pour */ /* la fin de SUJ. */ int I; /* indice courant dans SUJ */ int J; /* indice courant dans CH1 et CH2 */ int K; /* indice d'aide pour les copies */ /* Saisie des donnes */ printf("Introduisez la chane rechercher CH1 : "); gets(CH1); printf("Introduisez la chane remplacer CH2 : "); gets(CH2); printf("Introduisez la chane transformer SUJ : "); gets(SUJ); /* Recherche de CH1 dans SUJ */ for (I=0; SUJ[I]; I++) if (SUJ[I]==CH1[0]) { for (J=1; CH1[J] && (CH1[J]==SUJ[I+J]); J++) ; if (CH1[J]=='\0') /* TROUVE ! */ { /* Maintenant I indique la position de CH1 */ /* dans SUJ et J indique la longueur de CH1 */ /* Sauvegarder la fin de SUJ dans FIN */ for (K=0; SUJ[K+I+J]; K++) FIN[K]=SUJ[K+I+J]; FIN[K]='\0'; Page 139 sur 217

Module Langage de programmation structure


/* Copier CH2 dans SUJ et dplacer */ /* I derrire la copie de CH2. */ for (K=0; CH2[K]; K++,I++) SUJ[I]=CH2[K]; /* Recopier FIN dans SUJ */ for (K=0; FIN[K]; K++) SUJ[I+K]=FIN[K]; /* Terminer la chane SUJ */ SUJ[I+K]='\0'; I--; /* rajustement de l'indice I */ }

/* Affichage du rsultat */ printf("Chane rsultat : \"%s\"\n", SUJ); return 0; }

XI. Les pointeurs


La plupart des langages de programmation offrent la possibilit d'accder aux donnes dans la mmoire de l'ordinateur l'aide de pointeurs, c.--d. l'aide de variables auxquelles on peut attribuer les adresses d'autres variables. En C les pointeurs sont des variables contenant les adresses de d'autres variables.

A.

Adressage de variables

Avant de parler de pointeurs, il est indiqu de brivement passer en revue les deux modes d'adressage principaux: adressage direct et indirect.

1. Adressage direct
Dans la programmation, nous utilisons des variables pour stocker des informations. La valeur d'une variable se trouve un endroit spcifique dans la mmoire interne de l'ordinateur. Le nom de la variable nous permet alors d'accder directement cette valeur. Adressage direct: Accs au contenu d'une variable par le nom de la variable. Exemple

Page 140 sur 217

Module Langage de programmation structure


2. Adressage indirect
Si nous ne voulons pas utiliser le nom d'une variable A, nous pouvons copier l'adresse de cette variable dans une variable spciale P, appele pointeur. Adressage indirect: Accs au contenu d'une variable, en passant par un pointeur qui contient l'adresse de la variable Exemple: Soit A une variable contenant la valeur 10 et P un pointeur qui contient l'adresse de A. En mmoire, A et P peuvent se prsenter comme suit:

B.

Les pointeurs

Un pointeur est une variable spciale qui peut contenir l'adresse d'une autre variable. Si un pointeur P contient l'adresse d'une variable A, on dit que 'P pointe sur A'. Remarque: Les pointeurs et les noms de variables ont le mme rle: Ils donnent accs un emplacement dans la mmoire interne de l'ordinateur. Il faut quand mme bien faire la diffrence: Un pointeur est une variable qui peut 'pointer' sur diffrentes adresses. Le nom d'une variable reste toujours li la mme adresse.

1. Les oprateurs de base


Lors du travail avec des pointeurs, nous avons besoin: d'un oprateur 'adresse de': & pour obtenir l'adresse d'une variable d'un oprateur 'contenu de': * pour accder au contenu d'une adresse d'une syntaxe de dclaration pour pouvoir dclarer un pointeur

a) L'oprateur 'adresse de' : &


&<NomVariable> fournit l'adresse de la variable <NomVariable> L'oprateur & nous est dj familier par la fonction scanf, qui a besoin de l'adresse de ses arguments pour pouvoir leur attribuer de nouvelles valeurs Exemple: int N; printf("Entrez un nombre entier : "); scanf("%d", &N); Page 141 sur 217

Module Langage de programmation structure


Remarque: L'oprateur & peut seulement tre appliqu des objets qui se trouvent dans la mmoire interne, c.--d. des variables et des tableaux. Il ne peut pas tre appliqu des constantes ou des expressions Reprsentation schmatique Soit P un pointeur non initialis

Et A une variable (du mme type) contenant la valeur 10 :

Alors l'instruction P = &A; Affecte l'adresse de la variable A la variable P. Dans notre reprsentation schmatique, nous pouvons illustrer le fait que 'P pointe sur A' par une flche:

b) L'oprateur 'contenu de' : *


*<NomPointeur> dsigne le contenu de l'adresse rfrence par le pointeur <NomPointeur> Exemple: Soit A une variable contenant la valeur 10, B une variable contenant la valeur 50 et P un pointeur non initialis

Aprs les instructions, P = &A; B = *P; *P = 20;

Page 142 sur 217

Module Langage de programmation structure


- P pointe sur A, - le contenu de A (rfrenc par *P) est affect B, et - le contenu de A (rfrenc par *P) est mis 20.

c) Dclaration d'un pointeur


<Type> *<NomPointeur> dclare un pointeur <NomPointeur> qui peut recevoir des adresses de variables du type <Type> Une dclaration comme : int *PNUM; Peut tre interprte comme suit: "*PNUM est du type int" ou "PNUM est un pointeur sur int" ou "PNUM peut contenir l'adresse d'une variable du type int" Exemple: #include <stdio.h> #include <stdlib.h> int main () { int i=17,j; int *p; //dclaration du pointeur p=&i; //p pointe sur l'adresse de i j=*p; //c'est la mme chose que j = i; printf("j = %d\n",j); printf("p = %d\n",*p); *p=22; printf("p = %d\n",*p); printf("i = %d\n",i); printf("Fin du travail\n"); system("pause"); return 0; }

Page 143 sur 217

Module Langage de programmation structure

2. Les oprations lmentaires sur pointeurs


a) Priorit de * et &
Les oprateurs * et & ont la mme priorit que les autres oprateurs unaires (la ngation !, l'incrmentation ++, la dcrmentation --). Dans une mme expression, les oprateurs unaires *, &, !, ++, -- sont valus de droite gauche Si un pointeur P pointe sur une variable X, alors *P peut tre utilis partout o on peut crire X.

Exemple: Aprs l'instruction : P = &X; Les expressions suivantes, sont quivalentes: Y = *P+1 Y = X+1 *P = *P+10 *P += 2 ++*P ++X (*P)++ X++ Dans le dernier cas, les parenthses sont ncessaires: Comme les oprateurs unaires * et ++ sont valus de droite gauche, sans les parenthses le pointeur P serait incrment, non pas l'objet sur lequel P pointe. On peut uniquement affecter des adresses un pointeur. X = X+10 X += 2

b) Le pointeur NUL
Seule exception: La valeur numrique 0 (zro) est utilise pour indiquer qu'un pointeur ne pointe 'nulle part'.

int *P; P = 0; Finalement, les pointeurs sont aussi des variables et peuvent tre utiliss comme telles. Soit P1 et P2 deux pointeurs sur int, alors l'affectation: P1 = P2; Copie le contenu de P2 vers P1. P1 pointe alors sur le mme objet que P2

Page 144 sur 217

Module Langage de programmation structure


Rsumons:

Aprs les instructions: int A; int *P; P = &A; A dsigne le contenu de A &A dsigne l'adresse de A P dsigne l'adresse de A

*P dsigne le contenu de A En outre: &P dsigne l'adresse du pointeur P *A est illgal (puisque A n'est pas un pointeur) Exemple #include <stdio.h> #include <stdlib.h> int main () { double A = 1, B = 2; double *P1; P1=&A; printf("%d\n",P1); printf("%d\n",A); printf("%d\n",*P1); *P1=3; printf("%d\n",A); P1=&B; printf("%d\n",P1); P1++; printf("%d\n",P1);//il rajoute 8 octets comme cest un double printf("%d\n",*P1); (*P1)++; printf("%d\n",B); system("pause"); Page 145 sur 217

Module Langage de programmation structure


return 0; }

3. Exercice 1
main() { int A = 1; int B = 2; int C = 3; int *P1, *P2; P1=&A; P2=&C; *P1=(*P2)++; P1=P2; P2=&B; *P1-=*P2; ++*P2; *P1*=*P2; A=++*P2**P1; P1=&A; *P2=*P1/=*P2; return 0; } Copiez le tableau suivant et compltez-le pour chaque instruction du programme ci-dessus. A B C P1 P2 Init. P1=&A P2=&C *P1=(*P2)++ P1=P2 P2=&B *P1-=*P2 ++*P2 *P1*=*P2 Page 146 sur 217 1 2 3 / / 1 2 3 &A /

Module Langage de programmation structure


A=++*P2**P1 P1=&A *P2=*P1/=*P2

C.Pointeurs et tableaux
En C, il existe une relation trs troite entre tableaux et pointeurs. Ainsi, chaque opration avec des indices de tableaux peut aussi tre exprime l'aide de pointeurs.

1. Adressage des composantes d'un tableau


Le nom d'un tableau reprsente l'adresse de son premier lment. En d'autre terme: &tableau[0] et tableau Exemple En dclarant un tableau A de type int et un pointeur P sur int, int A[10]; int *P; L'instruction: P = A; est quivalente P = &A[0];

Si P pointe sur une composante quelconque d'un tableau, alors P+1 pointe sur la composante suivante. Ainsi, aprs l'instruction, P = A; le pointeur P pointe sur A[0], et *(P+1) dsigne le contenu de A[1] *(P+2) dsigne le contenu de A[2] ... Exemple Soit A un tableau contenant des lments du type float et P un pointeur sur float: Page 147 sur 217 ... *(P+i) dsigne le contenu de A[i]

Module Langage de programmation structure


float A[20], X; float *P; Aprs les instructions, P = A; X = *(P+9); X contient la valeur du 10-ime lment de A, (c.--d. celle de A[9]). Une donne du type float ayant besoin de 4 octets, le compilateur obtient l'adresse P+9 en ajoutant 9 * 4 = 36 octets l'adresse dans P. Comme A reprsente l'adresse de A[0], *(A+1) dsigne le contenu de A[1] *(A+2) dsigne le contenu de A[2] ... *(A+i) dsigne le contenu de A[i] Remarque: Il existe toujours une diffrence essentielle entre un pointeur et le nom d'un tableau: Un pointeur est une variable, donc des oprations comme P = A ou P++ sont permises Le nom d'un tableau est une constante donc des oprations comme A = P ou A++ sont impossibles

Rsum Soit un tableau A d'un type quelconque et i un indice pour les composantes de A, alors: A A+i dsigne l'adresse de dsigne l'adresse de A[0] A[i]

*(A+i) dsigne le contenu de A[i] Si P = A, alors P P+i pointe sur l'lment pointe sur l'lment A[0] A[i]

*(P+i) dsigne le contenu de A[i] Exemple Les deux programmes suivants copient les lments positifs d'un tableau T dans un deuxime tableau POS. Formalisme tableau:

main() { int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9}; int POS[10]; int I,J; /* indices courants dans T et POS */ for (J=0,I=0 ; I<10 ; I++) if (T[I]>0) Page 148 sur 217

Module Langage de programmation structure


{ POS[J] = T[I]; J++; } return 0; } Formalisme pointeur

main() { int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9}; int POS[10]; int I,J; /* indices courants dans T et POS */ for (J=0,I=0 ; I<10 ; I++) if (*(T+I)>0) { *(POS+J) = *(T+I); J++; } return 0; }

a) Exercice 2
Ecrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier et qui ajoute les lments de B la fin de A. Utiliser le formalisme pointeur chaque fois que cela est possible.

2. Pointeurs et chanes de caractres


a) Affectation
On peut attribuer l'adresse d'une chane de caractres constante un pointeur sur char: Exemple char *C; C = "Ceci est une chane de caractres constante";

b) Initialisation
Un pointeur sur char peut tre initialis lors de la dclaration si on lui affecte l'adresse d'une chane de caractres constante.

Page 149 sur 217

Module Langage de programmation structure


c) Remarque
Il existe une diffrence importante entre les deux dclarations: char A[] = "Bonjour !"; char *B = "Bonjour !"; /* un tableau */ /* un pointeur */

A est un tableau qui a exactement la grandeur pour contenir la chane de caractres et la terminaison '\0'. Les caractres de la chane peuvent tre changs, mais le nom A va toujours pointer sur la mme adresse en mmoire. B est un pointeur qui est initialis de faon ce qu'il pointe sur une chane de caractres constante stocke quelque part en mmoire. Le pointeur peut tre modifi et pointer sur autre chose. La chane constante peut tre lue, copie ou affiche, mais pas modifie.

d) Modification
Si nous affectons une nouvelle valeur un pointeur sur une chane de caractres constante, nous risquons de perdre la chane constante. D'autre part, un pointeur sur char a l'avantage de pouvoir pointer sur des chanes de n'importe quelle longueur: Exemple: char *A = "Petite chane"; char *B = "Deuxime chane un peu plus longue"; A = B; Maintenant A et B pointent sur la mme chane; la "Petite chane" est perdue:

Les affectations suivantes ne peuvent pas tre effectues avec des tableaux de caractres: char A[45] = "Petite chane"; char B[45] = "Deuxime chane un peu plus longue"; char C[30]; A = B; /* IMPOSSIBLE -> ERREUR !!! */ C = "Bonjour !"; /* IMPOSSIBLE -> ERREUR !!! */

e) Exercice 3
Ecrire un programme qui lit une chane de caractres CH et dtermine le nombre de mots contenus dans la chane. Utiliser un pointeur P, une variable logique, la fonction isspace et une variable numrique N qui contiendra le nombre des mots.

Page 150 sur 217

Module Langage de programmation structure


D. Correction des exercices

1. Exercice 1
A Init. P1=&A P2=&C *P1=(*P2)++ P1=P2 P2=&B *P1-=*P2 ++*P2 *P1*=*P2 P1=&A 1 1 1 3 3 3 3 3 3 B C P1 P2 2 3 / / 2 3 &A / 2 3 &A &C 2 4 &A &C 2 4 &C &C 2 4 &C &B 2 2 &C &B 3 2 &C &B 3 6 &C &B

A=++*P2**P1 24 4 6 &C &B 24 4 6 &A &B 6 6 &A &B *P2=*P1/=*P2 6

2. Exercice 2
#include <stdio.h> main() { /* Dclarations */ int A[100], B[50]; /* tableaux */ int N, M; /* dimensions des tableaux */ int I; /* indice courant */ /* Saisie des donnes */ printf("Dimension du tableau A (max.50) : "); scanf("%d", &N ); for (I=0; I<N; I++) { printf("Elment %d : ", I); scanf("%d", A+I); } printf("Dimension du tableau B (max.50) : "); scanf("%d", &M ); for (I=0; I<M; I++) { printf("Elment %d : ", I); scanf("%d", B+I); } Page 151 sur 217

Module Langage de programmation structure


/* Affichage des tableaux */ printf("Tableau donn A :\n"); for (I=0; I<N; I++) printf("%d ", *(A+I)); printf("\n"); printf("Tableau donn B :\n"); for (I=0; I<M; I++) printf("%d ", *(B+I)); printf("\n"); /* Copie de B la fin de A */ for (I=0; I<M; I++) *(A+N+I) = *(B+I); /* Nouvelle dimension de A */ N += M; /* Edition du rsultat */ printf("Tableau rsultat A :\n"); for (I=0; I<N; I++) printf("%d ", *(A+I)); printf("\n"); return 0; }

3. Exercice 3
#include <stdio.h> #include <ctype.h> main() { /* Dclarations */ char CH[101]; /* chane donne */ char *P; /* pointeur d'aide */ int N; /* nombre des mots */ int DANS_MOT; /* indicateur logique: */ /* vrai si P pointe l'intrieur un mot */ /* Saisie des donnes */ printf("Entrez une ligne de texte (max.100 caractres) :\n"); gets(CH); /* Compter les mots */ N=0; DANS_MOT=0; for (P=CH; *P; P++) if (isspace(*P)) DANS_MOT=0; else if (!DANS_MOT) { DANS_MOT=1; N++; } Page 152 sur 217

Module Langage de programmation structure


/* Affichage du rsultat (pour perfectionnistes) */ printf("La chane \"%s\" \nest forme de %d mot%c.\n", CH, N, (N==1)?' ':'s'); return 0; }

XII.Allocation dynamique de mmoire


A. Dclaration statique de donnes
Chaque variable dans un programme a besoin d'un certain nombre d'octets en mmoire. Jusqu'ici, la rservation de la mmoire s'est droule automatiquement par l'emploi des dclarations des donnes. Dans tous ces cas, le nombre d'octets rserver tait dj connu pendant la compilation. Nous parlons alors de la dclaration statique des variables.

a) Exemple 1
float A, B, C; /* rservation de 12 octets */ short D[10][20]; /* rservation de 400 octets */ char E[] = {"Bonjour !"}; /* rservation de 10 octets */ char F[][10] = {"un", "deux", "trois", "quatre"}; /* rservation de 40 octets */ Pour vrifier la taille occupe dans la mmoire , on dispose dune fonction en C : sizeof(type de donnes).

b) Exemple 2
#include<stdio.h> #include<stdlib.h> int main() { printf("char : %d octets\n", sizeof(char)); printf("int : %d octets\n", sizeof(int)); printf("long : %d octets\n", sizeof(long)); printf("float : %d octets\n", sizeof(float)); printf("double : %d octets\n", sizeof(double)); system("pause"); return 0; }

Page 153 sur 217

Module Langage de programmation structure

c) Exemple 3
#include<stdio.h> #include<stdlib.h> int main() { int T[3];// 3 x taille de int = 12 octets printf("Le tableau T de 3 int : %d octets\n", sizeof(T)); system("pause"); return 0; }

Donc, en suivant ce mme principe, la dclaration suivante : int tableau[100]; fait occuper 4 x 100 = 400 octets en mmoire, mme si le tableau est vide !

B.

Allocation dynamique
malloc ("Memory ALLOCation", c'est--dire "Allocation de mmoire") : demande au systme d'exploitation la permission d'utiliser de la mmoire. free ("Librer") : permet d'indiquer au S.E. que l'on n'a plus besoin de la mmoire qu'on avait demande. La place en mmoire est libre, un autre programme peut maintenant s'en servir au besoin.

Pour pouvoir allouer de faon dynamique la mmoire, on a besoin dinclure la bibliothque <stdlib.h> qui contient 2 fonctions :

1. La fonction malooc
La fonction malloc de la bibliothque <stdlib> nous aide localiser et rserver de la mmoire au cours d'un programme. Sa syntaxe est la suivante: malloc( <N> ): fournit l'adresse (type de retour est un pointeur) d'un bloc en mmoire de <N> octets libres ou la valeur zro s'il n'y a pas assez de mmoire.

Page 154 sur 217

Module Langage de programmation structure


2. La fonction free
Si nous n'avons plus besoin d'un bloc de mmoire que nous avons rserv l'aide de malloc, alors nous pouvons le librer l'aide de la fonction free de la bibliothque <stdlib>. Sa syntaxe est la suivante: free( <Pointeur> ): libre le bloc de mmoire dsign par le <Pointeur>; n'a pas d'effet si le pointeur a la valeur zro.

3. Exemple
On va crire un programme en C qui demande l'ge l'utilisateur et qui va le lui afficher. La variable utilise va tre alloue manuellement (ou dynamiquement) au lieu d'automatiquement par le S.E. #include<stdio.h> #include<stdlib.h>// ncessaire pour utiliser malloc et free int main() { int *memoireAllouee = NULL;// On cre un pointeur sur int car malloc renvoie void* (un pointeur) memoireAllouee = malloc(sizeof(int)); // Allocation de la mmoire //test du pointeur : si l'allocation a march, le pointeur contient une adresse, sinon il contient ladresse NULL if (memoireAllouee == NULL)// Si l'allocation a chou { exit(0);// On arrte immdiatement le programme } // Utilisation de la mmoire printf("Quel age avez-vous ? "); scanf("%d",memoireAllouee); printf("Vous avez %d ans\n",*memoireAllouee); free(memoireAllouee); // Libration de mmoire system("pause"); return 0; }

Si on opte pour lallocation automatique de la mmoire, le programme prcdent est quivalent : #include<stdio.h> #include<stdlib.h>// Facultatif Page 155 sur 217

Module Langage de programmation structure


int main() { int age = 0; // Allocation de la mmoire (automatique) par le S.E // Utilisation de la mmoire printf("Quel age avez-vous ? "); scanf("%d",&age); printf("Vous avez %d ans\n",age); system("pause"); return 0; }// Libration de la mmoire (automatique la fin de la fonction) par le S.E

C.Allocation dynamique dun tableau


La vraie utilit de lallocation dynamique est pour crer un tableau dont on ne connat pas la taille avant lexcution du programme.

1. Exemple
On veut crire un programme qui stocke l'ge de tous les amis de l'utilisateur dans un tableau, on peut utiliser : int ageAmis[15]; le problme est que lon ne sait pas lavance le nombre damis de lutilisateur, on ne le saura qu lexcution du programme. Voici une solution : #include<stdio.h> #include<stdlib.h> int main() { int nombreDAmis = 0, i = 0; int* ageAmis = NULL; // Ce pointeur va servir de tableau aprs l'appel du malloc // On demande le nombre d'amis l'utilisateur printf("Combien d'amis avez-vous ? "); scanf("%d", &nombreDAmis); if (nombreDAmis > 0) // Il faut qu'il ait au moins un ami { ageAmis = malloc(nombreDAmis * sizeof(int)); // On alloue de la mmoire pour le tableau if (ageAmis == NULL) // On vrifie si l'allocation a march ou pas { Page 156 sur 217

Module Langage de programmation structure


exit(0); // On arrte tout } // On demande l'ge des amis un un for (i = 0 ; i < nombreDAmis ; i++) { printf("Quel age a l'ami numero %d ? ", i + 1); scanf("%d", &ageAmis[i]); } // On affiche les ges stocks un un printf("\n\nVos amis ont les ages suivants :\n"); for (i = 0 ; i < nombreDAmis ; i++) { printf("%d ans\n", ageAmis[i]); } // On libre la mmoire alloue avec malloc, on n'en a plus besoin free(ageAmis); } system("pause"); return 0; }

XIII. Les structures


1. Introduction
Jusque l, nous avons toujours utiliss des variables contenants les mmes types de donnes (tableaux ou matrices dentiers ou rels), les structures sont des variables composes de plusieurs variables (ou CHAMPS) de types diffrents.

2. Exemple
#include <stdio.h> Page 157 sur 217

Module Langage de programmation structure


#include <stdlib.h> int main () { struct point { int x; int y; //x et y sont les champs de la struct point }; struct point a,b;//dclaration de variables de type point a.x=1; a.y=2; b.x=3; b.y=4; printf("la valeur de l'abscisse de a est : %d\n",a.x); printf("la valeur de l'ordonnee de b est : %d\n",b.y); printf("Fin du travail\n"); system("pause"); return 0; }

3. Exercice
Ecrire un programme en C qui permet de dclarer une structure nomme ensemble comportant un entier, un rel et un tableau de caractres, ce programme doit permettre de saisir les composantes de cette structure et de les afficher.

4. Corrig
#include <stdio.h> #include <stdlib.h> int main () { struct ensemble { int n; float x; char texte[50]; Page 158 sur 217

Module Langage de programmation structure


}; struct ensemble E; int i=0; //saisi des composantes de la structure : printf("Entrez un entier : "); scanf("%d",&E.n); printf("Entrez un reel : "); scanf("%f",&E.x); printf("Entrez un texte, tapez . pour terminer : "); scanf("%c",&E.texte[i]); do { i++; scanf("%c",&E.texte[i]); }while(E.texte[i]!='.'); //affichage des composantes de la structure : printf("\nAffichage des composantes de la structure E :\n"); printf("L'entier E.n = %d\n",E.n); printf("Le reel E.x = %.2f\n",E.x); printf("Le texte E.texte = "); i=0; while(E.texte[i]!='.') { printf("%c",E.texte[i]); i++; } printf("\n"); system("pause"); return 0; }

Page 159 sur 217

Module Langage de programmation structure

XIV.

Les fonctions

La structuration de programmes en sous-programmes se fait en C l'aide de fonctions. Les fonctions en C correspondent aux fonctions et procdures. Nous avons dj utilis des fonctions prdfinies dans des bibliothques standard (printf de <stdio>, strlen de <string>, pow de <math>, etc.). Dans ce chapitre, nous allons dcouvrir comment nous pouvons dfinir et utiliser nos propres fonctions.

A.

Modularisation de programmes

Jusqu'ici, nous avons rsolu nos problmes l'aide de fonctions prdfinies et d'une seule fonction nouvelle: la fonction principale main(). Pour des problmes plus complexes, nous obtenons ainsi de longues listes d'instructions, peu structures et par consquent peu comprhensibles. En plus, il faut souvent rpter les mmes suites de commandes dans le texte du programme, ce qui entrane un gaspillage de mmoire interne et externe.

1. La modularit et ses avantages


La plupart des langages de programmation nous permettent de subdiviser nos programmes en sous-programmes, fonctions ou procdures plus simples et plus compacts. A l'aide de ces structures nous pouvons modulariser nos programmes pour obtenir des solutions plus lgantes et plus efficientes. Avantage : Voici quelques avantages d'un programme modulaire: Meilleure lisibilit Diminution du risque d'erreurs Rutilisation de modules dj existants Simplicit de l'entretien Favorisation du travail en quipe

2. Exemples de modularisation en C
a) Exemple : Afficher un rectangle d'toiles
Le programme suivant permet d'afficher l'cran un rectangle de longueur L et de hauteur H, form d'astrisques '*' :

#include <stdio.h> Page 160 sur 217

Module Langage de programmation structure

main() { /* Prototypes des fonctions appeles par main */ void RECTANGLE(int L, int H); /* Dclaration des variables locales de main */ int L, H; /* Traitements */ printf("Entrer la longueur (>= 1): "); scanf("%d", &L); printf("Entrer la hauteur (>= 1): "); scanf("%d", &H); /* Afficher un rectangle d'toiles */ RECTANGLE(L,H); return 0; } Pour que la fonction soit excutable par la machine, il faut encore spcifier la fonction RECTANGLE void RECTANGLE(int L, int H) { /* Prototypes des fonctions appeles */ void LIGNE(int L); /* Dclaration des variables locales */ int I; /* Traitements */ /* Afficher H lignes avec L toiles */ for (I=0; I<H; I++) LIGNE(L); } Pour que la fonction RECTANGLE soit excutable par la machine, il faut spcifier la fonction LIGNE: void LIGNE(int L) { /* Affiche l'cran une ligne avec L toiles */ /* Dclaration des variables locales */ int I; /* Traitements */ for (I=0; I<L; I++) printf("*"); printf("\n"); } Schmatiquement, nous pouvons reprsenter la hirarchie des fonctions du programme comme suit:

Page 161 sur 217

Module Langage de programmation structure

B. La notion identificateurs
1. Bloc d'instruction

de

blocs

et

la

porte

des

Les fonctions en C sont dfinies l'aide de blocs d'instructions. Un bloc d'instructions est encadr d'accolades et compos de deux parties: Blocs d'instructions en C { <dclarations locales> <instructions> } Exemple La variable d'aide I est dclare l'intrieur d'un bloc conditionnel. Si la condition (N>0) n'est pas remplie, I n'est pas dfini. A la fin du bloc conditionnel, I disparat. if (N>0) { int I; for (I=0; I<N; I++) ... }

Page 162 sur 217

Module Langage de programmation structure


2. Variables locales
Les variables dclares dans un bloc d'instructions sont uniquement visibles l'intrieur de ce bloc. On dit que ce sont des variables locales ce bloc. Exemple La variable NOM est dfinie localement dans le bloc de la fonction HELLO. Ainsi, aucune autre fonction n'a accs la variable NOM: void HELLO(); { char NOM[20]; printf("Introduisez votre nom : "); gets(NOM); printf("Bonjour %s !\n", NOM); }

Exemple La dclaration de la variable I se trouve l'intrieur d'un bloc d'instructions conditionnel. Elle n'est pas visible l'extrieur de ce bloc. if (N>0) { int I; for (I=0; I<N; I++) ... } Remarque : Une variable dclare l'intrieur d'un bloc cache toutes les variables du mme nom des blocs qui l'entourent. Exemple : Dans la fonction suivante,

int FONCTION(int A); { int X; ... X = 100; Page 163 sur 217

Module Langage de programmation structure


... while (A>10) { double X; ... X *= A; ... } } La premire instruction X=100 se rapporte la variable du type int dclare dans le bloc extrieur de la fonction; l'instruction X*=A agit sur la variable du type double dclare dans la boucle while. A l'intrieur de la boucle, il est impossible d'accder la variable X du bloc extrieur.

3. Variables globales
Les variables dclares au dbut du fichier, l'extrieur de toutes les fonctions sont disponibles toutes les fonctions du programme. Ce sont alors des variables globales. En gnral, les variables globales sont dclares immdiatement derrire les instructions #include au dbut du programme. Remarque: Les variables dclares au dbut de la fonction principale main ne sont pas des variables globales, mais elles sont locales main ! Exemple: La variable STATUS est dclare globalement pour pouvoir tre utilise dans les procdures A et B. #include <stdio.h> int STATUS; void A(...) { ... if (STATUS>0) STATUS--; else ... ... Page 164 sur 217

Module Langage de programmation structure


} void B(...) { ... STATUS++; ... }

C.Dclaration et dfinition de fonctions


Une fonction est dfinie par son entte, suivie d'un bloc d'instructions Dclaration : type_retourn nom_fonction(liste_arguments ou paramtres). Exemple : int carre (int x) { } : carre est une fonction qui retourne un entier et qui a comme paramtre un entier. Si la fonction ne retourne rien on indique : void. (On parle de procdure) Exemple : void nom_fonction() {bloc dinstructions} : fonction sans paramtre et ne retournant rien (void).

1. Exemple 1
#include <stdio.h> #include <stdlib.h> void debut() // debut retourne rien { printf("message de debut\n"); } void fin(int a) // a paramtre formel { printf("valeur finale = %d\n",a); } int carre(int x) { int v; v=x*x; return v; // carre retourne un entier } int main () { int i,total; debut(); Page 165 sur 217

Module Langage de programmation structure


total=0; for(i=1;i<=2;i++) total=total+carre(i); fin(total); printf("Fin du travail\n"); system("pause"); return 0; }

D.

Passage des paramtres dune fonction

1. Passage par valeur


En C, le passage des paramtres se fait toujours par la valeur, c.--d. les fonctions n'obtiennent que les valeurs de leurs paramtres et n'ont pas d'accs aux variables elles-mmes. Les paramtres d'une fonction sont considrer comme des variables locales qui sont initialises automatiquement par les valeurs indiques lors d'un appel. A l'intrieur de la fonction, nous pouvons donc changer les valeurs des paramtres sans influencer les valeurs originales dans les fonctions appelantes. Exemple La fonction ETOILES dessine une ligne de N toiles. Le paramtre N est modifi l'intrieur de la fonction: void ETOILES(int N) { while (N>0) { printf("*"); N--; } printf("\n"); } La fonction TRIANGLE, appelle la fonction ETOILES en utilisant la variable L comme paramtre: void TRIANGLE(void) { Page 166 sur 217

Module Langage de programmation structure


int L; for (L=1; L<10; L++) ETOILES(L); } Au moment de l'appel, la valeur de L est copie dans N. La variable N peut donc tre dcrmente l'intrieur de ETOILES, sans influencer la valeur originale de L. Schmatiquement, le passage des paramtres peut tre reprsent dans une 'grille' des valeurs:

2. Passage par rfrence (Adresse)


Pour changer la valeur d'une variable de la fonction appelante, nous allons procder comme suit: la fonction appelante doit fournir l'adresse de la variable et la fonction appele doit dclarer le paramtre comme pointeur.

On peut alors atteindre la variable l'aide du pointeur. Discussion d'un exemple Nous voulons crire une fonction PERMUTER qui change le contenu de deux variables du type int. En premire approche, nous crivons la fonction suivante: void PERMUTER (int A, int B) { int AIDE; AIDE = A; A = B; B = AIDE; } Nous appelons la fonction pour deux variables X et Y par: Page 167 sur 217

Module Langage de programmation structure


PERMUTER(X, Y); Rsultat: X et Y restent inchangs ! Explication: Lors de l'appel, les valeurs de X et de Y sont copies dans les paramtres A et B. PERMUTER change bien contenu des variables locales A et B, mais les valeurs de X et Y restent les mmes.

Pour pouvoir modifier le contenu de X et de Y, la fonction PERMUTER a besoin des adresses de X et Y. En utilisant des pointeurs, nous crivons une deuxime fonction: void PERMUTER (int *A, int *B) { int AIDE; AIDE = *A; *A = *B; *B = AIDE; } Nous appelons la fonction par: PERMUTER(&X, &Y); Rsultat: Le contenu des variables X et Y est chang ! Explication: Lors de l'appel, les adresses de X et de Y sont copies dans les pointeurs A et B. PERMUTER change ensuite le contenu des adresses indiques par les pointeurs A et B.

3. Exemple
#include <stdio.h> #include <stdlib.h> void compte1(int i)//passage par valeur { i++; Page 168 sur 217

Module Langage de programmation structure


printf("La valeur du parametre de compte1 : %d\n",i); } void compte2(int &j)//passage par rfrence { j++; printf("La valeur du parametre de compte2 : %d\n",j); } void compte3(int t[3]) //tableau donc par rfrence { t[1]++; printf("La valeur du parametre de compte3 : %d\n",t[1]); } int main () { int a,b,r[3]; a=b=r[1]=1;//initialisations multiples compte1(a); printf("La valeur de l'argument de compte1 : %d\n",a); compte2(b); printf("La valeur de l'argument de compte2 : %d\n",b); compte3(r); printf("La valeur de l'argument de compte3 : %d\n",r[1]); printf("Fin du travail\n"); system("pause"); return 0; }

4. Exercice 1
Ecrire un programme se servant d'une fonction MOYENNE du type float pour afficher la moyenne arithmtique de deux nombres rels entrs au clavier.

Page 169 sur 217

Module Langage de programmation structure


5. Exercice 2
Ecrire deux fonctions qui calculent la valeur XN pour une valeur relle X (type double) et une valeur entire positive N (type int) : a) EXP1 retourne la valeur X N comme rsultat. b) EXP2 affecte la valeur XN X. Ecrire un programme qui teste les deux fonctions l'aide de valeurs lues au clavier.

6. Exercice 3
Ecrire une fonction MIN et une fonction MAX qui dterminent le minimum et le maximum de deux nombres rels. Ecrire un programme se servant des fonctions MIN et MAX pour dterminer le minimum et le maximum de quatre nombres rels entrs au clavier.

7. Exercice 4
Ecrire un programme se servant d'une fonction F pour afficher la table de valeurs de la fonction dfinie par f(x) = sin(x) + ln(x) o x est un entier compris entre 1 et 10.

8. Exercice 5
Ecrire la fonction NCHIFFRES du type int qui obtient une valeur entire N (positive ou ngative) du type long comme paramtre et qui fournit le nombre de chiffres de N comme rsultat. Ecrire un petit programme qui teste la fonction NCHIFFRES: Exemple: Introduire un nombre entier : 6457392 Le nombre 6457392 a 7 chiffres.

9. Exercice 6
Ecrivez un programme qui ralise le produit des 2 matrices :

1 0 1 0 1 0 1 0 1

2 3 4 0 7 0 2 3 4

Utilisez 2 fonctions : prodmat pour calculer le produit et ecritmat pour lafficher.

Page 170 sur 217

Module Langage de programmation structure


E.Correction des exercices
1. Exercice 1
#include <stdio.h> main() { /* Prototypes des fonctions appeles */ float MOYENNE(float X, float Y); /* Variables locales */ float A,B; /* Traitements */ printf("Introduire deux nombres : "); scanf("%f %f", &A, &B); printf("La moyenne arithmtique de %.2f et %.2f est %.4f\n", A, B, MOYENNE(A,B)); return 0; } float MOYENNE(float X, float Y) { return (X+Y)/2; }

2. Exercice 2
#include <stdio.h> main() { /* Prototypes des fonctions appeles */ double EXP1(double X, int N); void EXP2(double *X, int N); /* Variables locales */ double A; int B; /* Traitements */ printf("Introduire un rel X : "); scanf("%lf", &A); printf("Introduire l'exposant positif N : "); scanf("%d", &B); /* a */ printf("EXP1(%.2f , %d) = %f\n", A, B, EXP1(A,B)); /* b */ /* Comme la valeur initiale de A est perdue l'appel */ /* de EXP2, il faut partager l'affichage si on veut */ /* afficher la valeur de A avant et aprs l'appel ! */ Page 171 sur 217

Module Langage de programmation structure


printf("EXP2(%.2f , %d) = ", A, B); EXP2(&A, B); printf("%f\n", A); return 0; } double EXP1(double X, int N) { double RES; for (RES=1.0; N>0; N--) RES *= X; return RES; } void EXP2(double *X, int N) { double AIDE; for (AIDE=1.0; N>0; N--) AIDE *= *X; *X = AIDE; }

3. Exercice 3
#include <stdio.h> main() { /* Prototypes des fonctions appeles */ double MIN(double X, double Y); double MAX(double X, double Y); /* Variables locales */ double A,B,C,D; /* Traitements */ printf("Introduire 4 rels : "); scanf("%lf %lf %lf %lf", &A, &B, &C, &D); printf("Le minimum des 4 rels est %f \n", MIN( MIN(A,B), MIN(C,D)) ); printf("Le maximum des 4 rels est %f \n", MAX( MAX(A,B), MAX(C,D)) ); return 0; } double MIN(double X, double Y) { if (X<Y) return X; else return Y; Page 172 sur 217

Module Langage de programmation structure


} double MAX(double X, double Y) { if (X>Y) return X; else return Y; } /* ou bien */ /* double MIN(double X, double Y) { return (X<Y) ? X : Y; } double MAX(double X, double Y) { return (X>Y) ? X : Y; } */

4. Exercice 4
#include <stdio.h> #include <math.h> main() { /* Prototypes des fonctions appeles */ double F(int X); /* Variables locales */ int I; /* Traitements */ printf("\tX\tF(X)\n"); for (I=1 ; I<=10 ; I++) printf("\t%d\t%f\n", I, F(I)); return 0; } double F(int X) { return sin(X)+log(X)-sqrt(X); }

5. Exercice 5
#include <stdio.h> Page 173 sur 217

Module Langage de programmation structure


main() { /* Prototypes des fonctions appeles */ int NCHIFFRES(long N); /* Variables locales */ long A; /* Traitements */ printf("Introduire un nombre entier : "); scanf("%ld", &A); printf("Le nombre %ld a %d chiffres.\n",A ,NCHIFFRES(A)); return 0; } int NCHIFFRES(long N) { /* Comme N est transmis par valeur, N peut tre */ /* modifi l'intrieur de la fonction. */ int I; /* Conversion du signe si N est ngatif */ if (N<0) N *= -1; /* Compter les chiffres */ for (I=1; N>10; I++) N /= 10; return I; }

6. Exercice 6
#include <stdio.h> #include <stdlib.h> const int TMAX=3; typedef int matrice[TMAX][TMAX]; void prodmat(matrice m1,matrice m2,matrice m3)//matrice passage par rfrence { for(int i=0;i<TMAX;i++)//on commence par l'indice 0! for(int j=0;j<TMAX;j++) { int s=0; for(int k=0;k<TMAX;k++) s=s+(m1[i][k]*m2[k][j]);//() non ncessaire car priorit m3[i][j]=s; } } void ecritmat(matrice mat) Page 174 sur 217

Module Langage de programmation structure


{ for(int i=0;i<TMAX;i++) { for(int j=0;j<TMAX;j++) printf("%5d",mat[i][j]); printf("\n"); } } int main () { matrice mat1={{1,0,1},{0,1,0},{1,0,1}}; matrice mat2={{2,3,4},{0,7,0},{2,3,4}}; matrice mat3; prodmat(mat1,mat2,mat3); ecritmat(mat3); printf("Fin du travail\n"); system("pause"); return 0; }

XV. Algorithmes de Tri


A. Introduction
Dans ce chapitre passer en revue certains algorithmes de tri bien connus des tableaux. On va se proposer de les rassembler dans un mme programme, et on affectera chaque mthode de tri une fonction correspondante de manire ce quon puisse comparer ces diffrentes mthodes Rappel : Un tableau T est dit tri en ordre croissant si tous les lments conscutifs du tableau vrifient : T[i-1] T[i] -6 0 12 25 100

Page 175 sur 217

Module Langage de programmation structure


B. Tri par slection

1. Principe
Le principe du tri par slection d'un tableau est d'aller chercher le plus petit lment du tableau pour le mettre en premier, puis de repartir du deuxime, d'aller chercher le plus petit lment pour le mettre en 2me position et ainsi de suite... Au ime passage, on slectionne llment ayant la plus petite valeur parmi les positions i..n et on l'change avec T[i].

2. Algorithme
Voici lalgorithme correspondant : i,j : Entier ; Dbut pour i 0 n-2 faire { pour j i+1 n-1 faire { si (T[i] > T[j] ) alors change(T,i,j) ; } } Fin

3. Exemple :
4 0 0 0 0 5 5 2 2 2 0 4 4 3 3 2 2 5 5 4 3 3 3 4 5 Tableau de dpart Le plus petit lment est sa place Les 2 plus petits lments sont leur place Les 3 plus petits lments sont leur place Les 4 plus petits lments sont leur place

C.Tri bulles :
1. Principe
Le principe du tri bulles (bubble sort) est de comparer deux deux les lments e1 et e2 conscutifs d'un tableau et d'effecteur une permutation si e1 > e2. On continue de trier jusqu' ce qu'il n'y ait plus de permutation. Page 176 sur 217

Module Langage de programmation structure


2. Algorithme
Voici lalgorithme correspondant : i,j : Entier ; Dbut pour i 0 n-2 faire { pour j n-1 i+1 faire {dcroissant} { si (T[j-1] > T[j]) alors change(T,j-1,j) ; } } Fin

3. Exemple
4 0 0 0 2 4 2 2 0 2 4 3 3 3 3 4 5 5 5 5 Tableau de dpart Fin du 1er passage Fin du 2me passage Fin du 3me passage

D.

Exercice rcapitulatif
Une Une Une Une fonction fonction fonction fonction de lecture dun tableau, de tri par slection de ce tableau, de tri par bulles de ce tableau, daffichage du tableau tri.

Ecrire un programme utilisant 4 fonctions :

E.Correction de lexercice rcapitulatif


#include<stdio.h> #include<stdlib.h> typedef int tableau[15]; int N; // ************************************************* // Lecture du tableau void lecture(tableau T) { for (int i=0;i<N;i++) Page 177 sur 217

Module Langage de programmation structure


scanf("%d",&T[i]); } // ************************************************* // Tri par slection void tri_selection(tableau T) { int aux; for (int i=0;i<N-1;i++) for (int j=i+1;j<N;j++) if (T[i]>T[j]) { aux=T[i]; T[i]=T[j]; T[j]=aux; } } // ************************************************* // Tri par bulles void tri_bulles(tableau T) { int aux; for (int i=0;i<N-1;i++) for (int j=N-1;j>=i+1;j--) if (T[j-1]>T[j]) { aux=T[j-1]; T[j-1]=T[j]; T[j]=aux; } } // ************************************************* // Affichage du tableau void affichage(tableau T) { for (int i=0;i<N;i++) printf("%5d",T[i]); printf("\n"); } // ************************************************* int main() { tableau V; Page 178 sur 217

Module Langage de programmation structure


printf("Entrer la dimension du tableau : "); scanf("%d",&N); printf("Entrer les N valeurs du tableau : "); lecture(V); tri_selection(V); printf("Voici le tableau trie par selection :\n"); affichage(V); printf("Entrer de nouveau N autres valeurs du tableau : "); lecture(V); tri_bulles(V); printf("Voici le tableau trie par bulles :\n"); affichage(V); system("pause"); return 0; }

XVI.
A.

Fichiers squentiels

Notion de fichier

1. Introduction
En C, les communications d'un programme avec son environnement se font par l'intermdiaire de fichiers. Pour le programmeur, tous les priphriques, mme le clavier et l'cran, sont des fichiers. Jusqu'ici, nos programmes ont lu leurs donnes dans le fichier d'entre standard, (c.-d.: le clavier) et ils ont crit leurs rsultats dans le fichier de sortie standard (c.--d.: l'cran). Nous allons voir dans ce chapitre, comment nous pouvons crer, lire et modifier nousmmes des fichiers sur les priphriques disponibles

Page 179 sur 217

Module Langage de programmation structure


2. Dfinitions et proprits
a) Fichier
Un fichier (angl.: file) est un ensemble structur de donnes stock en gnral sur un support externe (disquette, disque dur, disque optique, bande magntique, ...).

b) Fichier squentiel
Dans des fichiers squentiels, les enregistrements sont mmoriss conscutivement dans l'ordre de leur entre et peuvent seulement tre lus dans cet ordre. Si on a besoin d'un enregistrement prcis dans un fichier squentiel, il faut lire tous les enregistrements qui le prcdent, en commenant par le premier. Exemple :

Proprits : Les fichiers squentiels que nous allons considrer dans ce cours auront les proprits suivantes : Les fichiers se trouvent ou bien en tat d'criture ou bien en tat de lecture; nous ne pouvons pas simultanment lire et crire dans le mme fichier A un moment donn, on peut uniquement accder un seul enregistrement; celui qui se trouve en face de la tte de lecture/criture Aprs chaque accs, la tte de lecture/criture est dplace derrire la donne lue en dernier lieu stdin le fichier d'entre standard stdout le fichier de sortie standard

Il existe deux fichiers spciaux qui sont dfinis par dfaut pour tous les programmes:

Cela signifie que les programmes lisent leurs donnes au clavier et crivent les rsultats sur l'cran.

3. La mmoire tampon (buffer)


Pour des raisons d'efficacit, les accs un fichier se font par l'intermdiaire d'une mmoire tampon (buffer en anglais). La mmoire tampon est une zone de la mmoire centrale de lordinateur rserve un ou plusieurs enregistrements du fichier. L'utilisation de la mmoire tampon a l'effet de rduire le nombre d'accs un priphrique de stockage d'une part et le nombre des mouvements de la tte de lecture/criture d'autre part :

Page 180 sur 217

Module Langage de programmation structure

4. Accs aux fichiers squentiels


a) Introduction
Les problmes traitant des fichiers ont gnralement la forme suivante: un fichier donn par son nom (et en cas de besoin le chemin d'accs sur le mdium de stockage), doit tre cr, lu ou modifi. La question qui se pose est alors: Comment pouvons-nous relier le nom d'un fichier sur un support externe avec les instructions qui donnent accs au contenu du fichier ? En rsum, la mthode employe sera la suivante: Avant de lire ou d'crire un fichier, l'accs est notifi par la commande fopen. fopen accepte le nom du fichier (p.ex: "A:\ADRESSES.DAT"), ngocie avec le systme d'exploitation et fournit un pointeur spcial qui sera utilis ensuite lors de l'criture ou la lecture du fichier. Aprs les traitements, il faut annuler la liaison entre le nom du fichier et le pointeur l'aide de la commande fclose. On peut dire aussi qu'entre les vnements fopen() et fclose() le fichier est ouvert.

b) Le type FILE*
Pour pouvoir travailler avec un fichier, un programme a besoin d'un certain nombre d'informations au sujet du fichier: adresse de la mmoire tampon, position actuelle de la tte de lecture/criture, type d'accs au fichier: criture, lecture, ... tat derreur

Ces informations (dont nous n'aurons pas nous occuper), sont rassembles dans une structure du type spcial FILE. Lorsque nous ouvrons un fichier avec la commande fopen, le systme gnre automatiquement un bloc du type FILE et nous fournit son adresse. Tout ce que nous avons faire dans notre programme est: dclarer un pointeur du type FILE* pour chaque fichier dont nous avons besoin, Page 181 sur 217

Module Langage de programmation structure


affecter l'adresse retourne par fopen ce pointeur, employer le pointeur la place du nom du fichier dans toutes les instructions de lecture ou d'criture, librer le pointeur la fin du traitement l'aide de fclose.

c) Exemple: Crer et afficher un fichier squentiel


On se propose de crer un fichier qui est form d'enregistrements contenant comme information le nom d'une personne. Chaque enregistrement est donc constitu d'une seule rubrique, savoir, le nom de la personne.

L'utilisateur doit entrer au clavier le nom du fichier, le nombre de personnes et les noms des personnes. Le programme se chargera de crer le fichier correspondant sur disque dur ou sur disquette. Aprs avoir crit et ferm le fichier, le programme va rouvrir le mme fichier en lecture et afficher son contenu, sans utiliser le nombre d'enregistrements introduit dans la premire partie. #include <stdio.h> main() { FILE *P_FICHIER; /* pointeur sur FILE */ char NOM_FICHIER[30], NOM_PERS[30]; int C,NB_ENREG; /* Premire partie : Crer et remplir le fichier */ printf("Entrez le nom du fichier crer : "); scanf("%s", NOM_FICHIER); P_FICHIER = fopen(NOM_FICHIER, "w"); /* write */ printf("Nombre d'enregistrements crer : "); scanf("%d", &NB_ENREG); C = 0; while (C<NB_ENREG) { printf("Entrez le nom de la personne : "); scanf("%s", NOM_PERS); fprintf(P_FICHIER, "%s\n", NOM_PERS); C++; Page 182 sur 217

Module Langage de programmation structure


} fclose(P_FICHIER); /* Deuxime partie : Lire et afficher le contenu du fichier */ P_FICHIER = fopen(NOM_FICHIER, "r"); /* read */ C = 0; while (!feof(P_FICHIER)) { fscanf(P_FICHIER, "%s\n", NOM_PERS); printf("NOM : %s\n", NOM_PERS); C++; } fclose(P_FICHIER); return 0; }

5. Ouvrir et fermer des fichiers squentiels


L'ouverture et la fermeture de fichiers se font l'aide des fonctions fopen et fclose dfinies dans la bibliothque standard <stdio>.

a) Ouvrir un fichier squentiel


Lors de l'ouverture d'un fichier avec fopen, le systme s'occupe de la rservation de la mmoire tampon dans la mmoire centrale et gnre les informations pour un nouvel lment du type FILE. L'adresse de ce bloc est retourne comme rsultat si l'ouverture s'est droule avec succs. La commande fopen peut ouvrir des fichiers en criture ou en lecture en dpendance de son deuxime paramtre ("r" ou "w") : <FP> = fopen ( <Nom> , "w" ); Ou bien <FP> = fopen ( <Nom> , "r" ); <Nom> est une chane de caractres constante ou une variable de type chane qui reprsente le nom du fichier sur le mdium de stockage. le deuxime argument dtermine le mode d'accs au fichier: "w" pour 'ouverture en criture' - write "r" pour 'ouverture en lecture' - read <FP> est un pointeur du type FILE* qui sera reli au fichier sur le mdium de stockage. Dans la suite du programme, il faut utiliser <FP> au lieu de <Nom> pour rfrencer le fichier <FP> doit tre dclar comme: FILE *FP;

Le rsultat de fopen Si le fichier a pu tre ouvert avec succs, fopen fournit l'adresse d'un nouveau bloc du type FILE. En gnral, la valeur de cette adresse ne nous intresse pas; elle est simplement Page 183 sur 217

Module Langage de programmation structure


affecte un pointeur <FP> du type FILE* que nous utiliserons ensuite pour accder au fichier. A l'apparition d'une erreur lors de l'ouverture du fichier, fopen fournit la valeur numrique zro qui est souvent utilise dans une expression conditionnelle pour assurer que le traitement ne continue pas avec un fichier non ouvert Ouverture en criture Dans le cas de la cration d'un nouveau fichier, le nom du fichier est ajout au rpertoire de stockage. Si un fichier existant est ouvert en criture, alors son contenu est perdu. Si un fichier non existant est ouvert en criture, alors il est cr automatiquement. Si la cration du fichier est impossible alors fopen indique une erreur en retournant la valeur zro.

b) Fermer un fichier squentiel


On utilise linstruction : fclose( <FP> ); La fonction fclose provoque le contraire de fopen: Si le fichier a t ouvert en criture, alors les donnes non crites de la mmoire tampon sont crites et les donnes supplmentaires (longueur du fichier, date et heure de sa cration) sont ajoutes dans le rpertoire du mdium de stockage. Si le fichier a t ouvert en lecture, alors les donnes non lues de la mmoire tampon sont simplement 'jetes'. La mmoire tampon est ensuite libre et la liaison entre le pointeur sur FILE et le nom du fichier correspondant est annule. Aprs fclose() le pointeur <FP> est invalide.

c) Exemple 1 :
Lexemple suivant permet la cration du fichier : fichier1.txt la racine du disque d : , et insre le texte : Cration d'un nouveau fichier dans ce fichier :

#include <stdio.h> #include <stdlib.h> int main () { FILE *index=NULL;//dclaration de fichiers index = fopen("d:fichier1.txt","w");//ouverture en criture if (index == NULL) printf("Probleme d'ouverture\n"); else printf("Pas de probleme d'ouverture\n"); fputs("Creation d'un nouveau fichier", index); fclose(index); printf("Fin du travail\n"); Page 184 sur 217

Module Langage de programmation structure


system("pause"); return 0; }

d) Exemple 2
Cet exemple nous montre que louverture en criture dun fichier existant a pour effet de faire perdre son contenu : Voici le contenu du fichier prcdent ouvert en criture :

#include <stdio.h> #include <stdlib.h> int main () { FILE *index;//dclaration de fichiers index = fopen("d:\\fichier1.txt","w");//ouverture en criture if (index == NULL) printf("Probleme d'ouverture\n"); else printf("Pas de probleme d'ouverture\n"); fputs("Ouverture en criture d'un fichier existant, son contenu est alors perdu!", index); fclose(index); printf("Fin du travail\n"); system("pause"); return 0; }

e) Exemple 3
Le programme suivant contrle si louverture du fichier a t ralise avec succs, dabord louverture en criture : #include <stdio.h> #include <stdlib.h> main() { FILE *index=NULL; /* pointeur sur FILE */

char nom_fichier[30]; /* nom du fichier */ do { Page 185 sur 217

Module Langage de programmation structure


printf("Entrez le nom du fichier : "); scanf("%s", nom_fichier); index = fopen(nom_fichier, "w"); if (!index) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", nom_fichier); }while (!index); fclose(index); system("pause"); return 0; }

f) Exemple 4
Ensuite louverture en lecture : #include <stdio.h> #include <stdlib.h> main() { FILE *index; /* pointeur sur FILE */ char nom_fichier[30]; /* nom du fichier */ do { printf("Entrez le nom du fichier : "); scanf("%s", nom_fichier); index = fopen(nom_fichier, "r"); if (!index) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", nom_fichier); }while (!index); fclose(index); system("pause"); return 0; }

6. Lire et crire dans des fichiers squentiels


Les fichiers que nous employons dans ce manuel sont des fichiers texte, c.--d. toutes les informations dans les fichiers sont mmorises sous forme de chanes de caractres et sont organises en lignes. Mme les valeurs numriques (types int, float, double, ...) sont stockes comme chanes de caractres. Page 186 sur 217

Module Langage de programmation structure


Pour l'criture et la lecture des fichiers, nous allons utiliser les fonctions standard fprintf, fscanf, fputc et fgetc qui correspondent printf, scanf, putchar et getchar si nous indiquons stdout respectivement stdin comme fichiers de sortie ou d'entre.

a) Traitement par enregistrements


Les fichiers texte sont gnralement organiss en lignes, c.--d. la fin d'une information dans le fichier est marque par le symbole '\n':

Pour pouvoir lire correctement les enregistrements dans un fichier squentiel, le programmeur doit connatre l'ordre des diffrentes rubriques (champs) l'intrieur des enregistrements. Ecrire une information dans un fichier squentiel Pour cela on utilise : fprintf( <FP>, "<Form1>\n", <Expr1>); fprintf( <FP>, "<Form2>\n", <Expr2>); ... fprintf( <FP>, "<FormN>\n", <ExprN>); Ou bien : fprintf(<FP>,"<Form1>\n<Form2>\n...\n<FormN>\n", <Expr1>, <Expr2>, ... <ExprN>); <FP> est un pointeur du type FILE* qui est reli au nom du fichier cible <Expr1>, <Expr2>, ... , <ExprN> reprsentent les rubriques qui forment un enregistrement et dont les valeurs respectives sont crites dans le fichier <Form1>, <Form2>, ... , <FormN> reprsentent les spcificateurs de format pour l'criture des diffrentes rubriques ,

Remarque : L'instruction fprintf(stdout, "Bonjour\n"); Est identique printf("\Bonjour\n"); Notez que fprintf (et printf) crit toutes les chanes de caractres sans le symbole de fin de chane '\0'. Dans les fichiers texte, il faut ajouter le symbole de fin de ligne '\n' pour sparer les donnes. Lire une information dans un fichier squentiel Page 187 sur 217

Module Langage de programmation structure


Pour cela on utilise : fscanf( <FP>, "<Form1>\n", <Adr1>); fscanf( <FP>, "<Form2>\n", <Adr2>); ... fscanf( <FP>, "<FormN>\n", <AdrN>); Ou bien : fscanf(<FP>,"<Form1>\n<Form2>\n...\n<FormN>\n", <Adr1>, <Adr2>, ... , <AdrN>); <FP> est un pointeur du type FILE* qui est reli au nom du fichier lire. <Adr1>, <Adr2>, ... , <AdrN> reprsentent les adresses des variables qui vont recevoir les valeurs des diffrentes rubriques d'un enregistrement lu dans le fichier. <Form1>, <Form2>, ... , <FormN> reprsentent les spcificateurs de format pour la lecture des diffrentes rubriques

Remarque : L'instruction fscanf(stdin, "%d\n", &N); Est identique scanf("%d\n", &N); Pour les fonctions scanf et fscanf tous les signes d'espacement sont quivalents comme sparateurs. En consquence, l'aide de fscanf, il nous sera impossible de lire toute une phrase dans laquelle les mots sont spars par des espaces. Exemple 1 Ecrire un programme qui ouvre un fichier en criture w et qui affiche dedans 5 entiers saisis au clavier. On utilisera la fonction : fprintf. // Programme qui crit 5 entiers dans un fichier ouvert en criture #include <stdio.h> #include <stdlib.h> main() { FILE *index; int n; do { printf("Entrez le nom du fichier : "); scanf("%s", nom_fichier); index = fopen(nom_fichier, "w"); if (!index) printf("\aERREUR: Impossible d'ouvrir " Page 188 sur 217 /* pointeur sur FILE */ char nom_fichier[30]; /* nom du fichier */

Module Langage de programmation structure


"le fichier: %s.\n", nom_fichier); }while (!index); printf("Saisir 5 entiers : "); for (int i=1;i<=5;i++) { scanf("%d %d",&n,&m); fprintf(index, "%d %d\n", n ,m); } fclose(index); system("pause"); return 0; }

Exemple 2 Ecrire un programme qui ouvre, en lecture, le fichier cre par le programme prcdent et qui lit et affiche lcran les 5 entiers insrs dans ce fichier. // Programme qui ouvre, en lecture, le fichier cre par le programme prcdent //et qui lit et affiche les 5 entiers insrs dans ce fichier #include <stdio.h> #include <stdlib.h> main() { FILE *index=NULL; int n; Page 189 sur 217 /* pointeur sur FILE */ char nom_fichier[30]; /* nom du fichier */

Module Langage de programmation structure


do { printf("Entrez le nom du fichier : "); scanf("%s", nom_fichier); index = fopen(nom_fichier, "r"); if (!index) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", nom_fichier); }while (!index); for (int i=1;i<=5;i++) { fscanf(index, "%d",&n); printf("%d\n",n); } fclose(index); system("pause"); return 0; }

b) Traitement par caractres


La manipulation de fichiers avec les instructions fprintf et fscanf n'est pas assez flexible pour manipuler de faon confortable des textes crits. Il est alors avantageux de traiter le fichier squentiellement caractre par caractre. Ecrire un caractre dans un fichier squentiel - fputc Pour ce la on utilise : fputc( <C> , <FP> ); fputc transfre le caractre indiqu par <C> dans le fichier rfrenc par <FP> et avance la position de la tte de lecture/criture au caractre suivant. Remarque : L'instruction fputc('a', stdout); Est identique putchar('a'); Lire un caractre dans un fichier squentiel - fgetc Pour cela on utilise :

Page 190 sur 217

Module Langage de programmation structure


<C> = fgetc( <FP> ); fgetc fournit comme rsultat le prochain caractre du fichier rfrenc par <FP> et avance la position de la tte de lecture/criture au caractre suivant. Remarque : L'instruction C = fgetc(stdin); Est identique C = getchar(); Exemple 1 Le programme suivant lit et affiche le fichier "C:\CONFIG.SYS" en le parcourant caractre par caractre: #include <stdio.h> #include <stdlib.h> main() { FILE *index; index = fopen("C:\\CONFIG.SYS ", "r"); if (!index) { printf("Impossible d'ouvrir le fichier\n"); exit(-1); } while (!feof(index)) putchar(fgetc(index)); fclose(index); system("pause") ; return 0; }

c) Dtection de la fin d'un fichier squentiel


Lors de la fermeture d'un fichier ouvert en criture, la fin du fichier est marque automatiquement par le symbole de fin de fichier EOF (End Of File). Lors de la lecture d'un fichier, la fonction feof(<FP>) nous permet de dtecter la fin du fichier: Pour dtecter la fin dun fichier on utilise linstruction : feof( <FP> ); feof retourne une valeur diffrente de zro, si la tte de lecture du fichier rfrenc par <FP> est arrive la fin du fichier; sinon la valeur du rsultat est zro. Exemple : Le programme suivant lit et affiche le fichier "C:\AUTOEXEC.BAT" en le parcourant caractre par caractre: #include <stdio.h> Page 191 sur 217

Module Langage de programmation structure


#include <stdlib.h> main() { FILE *FP; FP = fopen("C:\\AUTOEXEC.BAT", "r"); if (!FP) { printf("Impossible d'ouvrir le fichier\n"); exit(-1); } while (!feof(FP)) putchar(fgetc(FP)); fclose(FP); return 0; }

d) Exercice rcapitulatif
Crer la racine du lecteur de disque C : puis afficher l'cran le fichier INFORMATION.TXT dont les informations (informations gnrales sur des personnes : clients) sont structures de la manire suivante : - Numro de matricule (entier) - Nom (chane de caractres) - Prnom (chane de caractres) - Le nombre d'enregistrements crer est entrer au clavier par l'utilisateur.

e) Correction
#include <stdio.h> #include <stdlib.h> int main() { // Dclarations // Nom du fichier et pointeur de rfrence

char NOM_FICH[] = "C:\\INFORMATION.TXT"; FILE *FICHIER; // Autres variables : char NOM[30], PRENOM[30]; int MATRICULE; int N_ENR; // Ouverture du nouveau fichier en criture FICHIER = fopen(NOM_FICH, "w"); if (!FICHIER) Page 192 sur 217

Module Langage de programmation structure


{ printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } // Saisie des donnes et cration du fichier printf("*** Creation du fichier %s ***\n", NOM_FICH); printf("Nombre d'enregistrements a creer : "); scanf("%d",&N_ENR); for (int i=1;i<=N_ENR;i++) { printf("Enregistrement No: %d \n", i); printf("Numero de matricule : "); scanf("%d",&MATRICULE); printf("Nom : "); scanf("%s",NOM); printf("Prnom : "); scanf("%s",PRENOM); fprintf(FICHIER, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); } // Fermeture du fichier fclose(FICHIER); // Ouverture du fichier en lecture FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } // Affichage du fichier printf("*** Contenu du fichier %s ***\n", NOM_FICH); while (!feof(FICHIER)) { fscanf(FICHIER, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); printf("Matricule : %d\t", MATRICULE); printf("Nom et prenom : %s %s\n", NOM, PRENOM); } // Fermeture du fichier fclose(FICHIER); Page 193 sur 217

Module Langage de programmation structure


system("pause"); return 0; }

7. Mise jour d'un fichier squentiel en C


Nous allons rsoudre les problmes standards sur les fichiers, savoir: L'ajout d'un enregistrement un fichier La suppression d'un enregistrement dans un fichier La modification d'un enregistrement dans un fichier

Comme il est impossible de lire et d'crire en mme temps dans un fichier squentiel, les modifications doivent se faire l'aide d'un fichier supplmentaire. Nous travaillons donc typiquement avec au moins deux fichiers: l'ancien fichier ouvert en lecture et le nouveau fichier ouvert en criture:

Page 194 sur 217

Module Langage de programmation structure

a) Ajouter un enregistrement un fichier


Nous pouvons ajouter le nouvel enregistrement diffrentes positions dans le fichier. Ajout la fin du fichier L'ancien fichier est entirement copi dans le nouveau fichier, suivi du nouvel enregistrement.

Ajout au dbut du fichier L'ancien fichier est copi derrire le nouvel enregistrement qui est crit en premier lieu.

Page 195 sur 217

Module Langage de programmation structure

Insertion dans un enregistrements

fichier

tri

relativement

une

rubrique

commune

des

Le nouveau fichier est cr en trois tapes : Copier les enregistrements de l'ancien fichier qui prcdent le nouvel enregistrement, Ecrire le nouvel enregistrement, Copier le reste des enregistrements de l'ancien fichier.

Exemple : Le programme suivant effectue l'insertion d'un enregistrement introduire au clavier dans un fichier tri selon la seule rubrique de ses enregistrements: le nom d'une personne. Le programme inclut en mme temps les solutions aux deux problmes prcdents. La comparaison lexicographique des noms des personnes se fait l'aide de la fonction strcmp. #include <stdio.h> #include <string.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[30], NOUVEAU[30]; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM_PERS[30], NOM_AJOUT[30]; Page 196 sur 217

Module Langage de programmation structure


int TROUVE; /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom de l'ancien fichier : "); scanf("%s", ANCIEN); INFILE = fopen(ANCIEN, "r"); if (!INFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); } while (!INFILE); /* Ouverture du nouveau fichier en criture */ do { printf("Nom du nouveau fichier : "); scanf("%s", NOUVEAU); OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); } while (!OUTFILE); /* Saisie de l'enregistrement insrer */ printf("Enregistrement insrer : "); scanf("%s",NOM_AJOUT); /* Traitement */ TROUVE = 0; /* Copie des enregistrements dont le nom */ /* prcde lexicogr. celui insrer.*/ while (!feof(INFILE) && !TROUVE) { fscanf(INFILE, "%s\n", NOM_PERS); if (strcmp(NOM_PERS, NOM_AJOUT) > 0) TROUVE = 1; else fprintf(OUTFILE, "%s\n", NOM_PERS); } /* Ecriture du nouvel enregistrement, */ fprintf(OUTFILE, "%s\n", NOM_AJOUT); /* suivi du dernier enregistrement lu. */ if (TROUVE) fprintf(OUTFILE, "%s\n", NOM_PERS); /* Copie du reste des enregistrements */ while (!feof(INFILE)) { fscanf(INFILE, "%s\n", NOM_PERS); fprintf(OUTFILE, "%s\n", NOM_PERS); Page 197 sur 217

Module Langage de programmation structure


} /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

b) Supprimer un enregistrement dans un fichier


Le nouveau fichier est cr en copiant tous les enregistrements de l'ancien fichier qui prcdent l'enregistrement supprimer et tous ceux qui le suivent:

Le programme correspondant : #include <stdio.h> #include <string.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[30], NOUVEAU[30]; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM_PERS[30], NOM_SUPPR[30]; /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom de l'ancien fichier : "); scanf("%s", ANCIEN); INFILE = fopen(ANCIEN, "r"); if (!INFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); } while (!INFILE); /* Ouverture du nouveau fichier en criture */ Page 198 sur 217

Module Langage de programmation structure


do { printf("Nom du nouveau fichier : "); scanf("%s", NOUVEAU); OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); } while (!OUTFILE); /* Saisie de l'enregistrement supprimer */ printf("Enregistrement supprimer : "); scanf("%s",NOM_SUPPR); /* Traitement */ /* Copie de tous les enregistrements */ /* l'exception de celui supprimer. */ while (!feof(INFILE)) { fscanf(INFILE, "%s\n", NOM_PERS); if (strcmp(NOM_PERS, NOM_SUPPR) != 0) fprintf(OUTFILE, "%s\n", NOM_PERS); } /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

c) Modifier un enregistrement dans un fichier


Le nouveau fichier est cr de tous les enregistrements de l'ancien fichier qui prcdent l'enregistrement modifier, de l'enregistrement modifi et de tous les enregistrements qui suivent l'enregistrement modifier dans l'ancien fichier:

Le programme correspondant :

Page 199 sur 217

Module Langage de programmation structure


#include <stdio.h> #include <string.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[30], NOUVEAU[30]; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM_PERS[30], NOM_MODIF[30], NOM_NOUV[30]; /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom de l'ancien fichier : "); scanf("%s", ANCIEN); INFILE = fopen(ANCIEN, "r"); if (!INFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); } while (!INFILE); /* Ouverture du nouveau fichier en criture */ do { printf("Nom du nouveau fichier : "); scanf("%s", NOUVEAU); OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); } while (!OUTFILE); /* Saisie de l'enregistrement modifier, */ printf("Enregistrement modifier : "); scanf("%s",NOM_MODIF); /* et de sa nouvelle valeur. */ printf("Enregistrement nouveau : "); scanf("%s",NOM_NOUV); /* Traitement */ /* Copie de tous les enregistrements en */ /* remplaant l'enregistrement modifier */ /* par sa nouvelle valeur. */ while (!feof(INFILE)) { fscanf(INFILE, "%s\n", NOM_PERS); if (strcmp(NOM_PERS, NOM_MODIF) = 0) fprintf(OUTFILE, "%s\n", NOM_NOUV); Page 200 sur 217

Module Langage de programmation structure


else fprintf(OUTFILE, "%s\n", NOM_PERS); } /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

8. Exercice 1
Crer sur disquette puis afficher l'cran le fichier INFORM.TXT dont les informations sont structures de la manire suivante: Numro de matricule (entier) Nom (chane de caractres) Prnom (chane de caractres) Le nombre d'enregistrements crer est entrer au clavier par l'utilisateur.

9. Exercice 2
Ecrire un programme qui cre sur disquette un fichier INFBIS.TXT qui est la copie exacte (enregistrement par enregistrement) du fichier INFORM.TXT.

10. Exercice 3
Ajouter un nouvel enregistrement (entr au clavier) la fin de INFORM.TXT et sauver le nouveau fichier sous le nom INFBIS.TXT.

11. Exercice 4
Insrer un nouvel enregistrement dans INFORM.TXT en supposant que le fichier est tri relativement la rubrique NOM et sauver le nouveau fichier sous le nom INFBIS.TXT.

12. Exercice 5
Supprimer dans INFORM.TXT tous les enregistrements: a) dont le numro de matricule se termine par 8 b) dont le prnom est "Paul" (utiliser strcmp) c) dont le nom est un palindrome. Dfinir une fonction d'aide PALI qui fournit le rsultat 1 si la chane transmise comme paramtre est un palindrome, sinon la valeur zro. Sauver le nouveau fichier chaque fois sous le nom INFBIS.TXT.

Page 201 sur 217

Module Langage de programmation structure


13. Exercice 6
Crer sur disquette puis afficher l'cran le fichier FAMILLE.TXT dont les informations sont structures de la manire suivante: Nom de famille Prnom du pre Prnom de la mre Nombre d'enfants Prnoms des enfants Le nombre d'enregistrements crer est entr au clavier. Attention: Le nombre de rubriques des enregistrements varie avec le nombre d'enfants !

14. Exercice 7
Ecrire un programme qui cre sur disquette le fichier MOTS.TXT contenant une srie de 50 mots au maximum (longueur maximale d'un mot: 50 caractres). La saisie des mots se terminera l'introduction du symbole '*' qui ne sera pas crit dans le fichier.

15. Exercice 8
A l'aide d'un diteur de textes, crer un fichier NOMBRES.TXT qui contient une liste de nombres entiers. Dans le fichier, chaque nombre doit tre suivi par un retour la ligne. Ecrire un programme qui affiche les nombres du fichier, leur somme et leur moyenne.

16. Exercice 9
Ecrire un programme qui remplace, dans un fichier contenant un texte, les retours la ligne par des espaces. Si plusieurs retours la ligne se suivent, seulement le premier sera remplac. Les noms des fichiers source et destination sont entrs au clavier.

17. Exercice 10
Ecrire un programme qui dtermine dans un fichier un texte dont le nom est entr au clavier: - le nombre de caractres qu'il contient, - le nombre de chacune des lettres de l'alphabet (sans distinguer les majuscules et les minuscules), - le nombre de mots, - le nombre de paragraphes (c.--d.: des retours la ligne), Les retours la ligne ne devront pas tre comptabiliss dans les caractres. On admettra que deux mots sont toujours spars par un ou plusieurs des caractres suivants: - fin de ligne - espace - ponctuation: . : , ; ? ! - parenthses: ( ) Page 202 sur 217

Module Langage de programmation structure


- guillemets: " - apostrophe: ' Utiliser une fonction d'aide SEPA qui dcide si un caractre transmis comme paramtre est l'un des sparateurs mentionns ci-dessus. SEPA restituera la valeur (logique) 1 si le caractre est un sparateur et 0 dans le cas contraire. SEPA utilise un tableau qui contient les sparateurs dtecter. Exemple: Nom du fichier texte : A:LITTERA.TXT Votre fichier contient: 12 paragraphes 571 mots 4186 caractres dont 279 fois la lettre a 56 fois la lettre b ... 3 fois la lettre z et 470 autres caractres

B.

Correction des exercices

1. Exercice 1
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Nom du fichier et pointeur de rfrence */ char NOM_FICH[] = "A:\\INFORM.TXT"; FILE *FICHIER; /* Autres variables */ char NOM[30], PRENOM[30]; int MATRICULE; int I,N_ENR; /* Ouverture du nouveau fichier en criture */ FICHIER = fopen(NOM_FICH, "w"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Saisie des donnes et cration du fichier */ Page 203 sur 217

Module Langage de programmation structure


printf("*** Cration du fichier %s ***\n", NOM_FICH); printf("Nombre d'enregistrements crer : "); scanf("%d",&N_ENR); for (I=1; I<=N_ENR; I++) { printf("Enregistrement No: %d \n", I); printf("Numro de matricule : "); scanf("%d",&MATRICULE); printf("Nom : "); scanf("%s",NOM); printf("Prnom : "); scanf("%s",PRENOM); fprintf(FICHIER, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); } /* Fermeture du fichier */ fclose(FICHIER); /* Ouverture du fichier en lecture */ FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Affichage du fichier */ printf("*** Contenu du fichier %s ***\n", NOM_FICH); while (!feof(FICHIER)) { fscanf(FICHIER, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); printf("Matricule : %d\t", MATRICULE); printf("Nom et prnom : %s %s\n", NOM, PRENOM); } /* Fermeture du fichier */ fclose(FICHIER); return 0; }

2. Exercice 2
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[] = "A:\\INFORM.TXT"; char NOUVEAU[] = "A:\\INFBIS.TXT"; FILE *INFILE, *OUTFILE; Page 204 sur 217

Module Langage de programmation structure


/* Autres variables */ char NOM[30], PRENOM[30]; int MATRICULE; /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN, "r"); if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); exit(-1); } /* Ouverture du nouveau fichier en criture */ OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); exit(-1); } /* Copie de tous les enregistrements */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); } /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

3. Exercice 3
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[] = "A:\\INFORM.TXT"; char NOUVEAU[] = "A:\\INFBIS.TXT"; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM[30], PRENOM[30]; int MATRICULE; char NOM_NOUV[30], PRE_NOUV[30]; Page 205 sur 217

Module Langage de programmation structure


int MATRI_NOUV; /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN, "r"); if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); exit(-1); } /* Ouverture du nouveau fichier en criture */ OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); exit(-1); } /* Saisie de l'enregistrement ajouter */ printf("Enregistrement ajouter : \n"); printf("Numro de matricule : "); scanf("%d",&MATRI_NOUV); printf("Nom : "); scanf("%s",NOM_NOUV); printf("Prnom : "); scanf("%s",PRE_NOUV); /* Copie des enregistrements de l'ancien fichier */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); } /* Ecriture du nouvel enregistrement la fin du fichier */ fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV); /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

4. Exercice 4
#include <stdio.h> #include <stdlib.h> #include <string.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ Page 206 sur 217

Module Langage de programmation structure


char ANCIEN[] = "A:\\INFORM.TXT"; char NOUVEAU[] = "A:\\INFBIS.TXT"; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM[30], PRENOM[30]; int MATRICULE; char NOM_NOUV[30], PRE_NOUV[30]; int MATRI_NOUV; int TROUVE; /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN, "r"); if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); exit(-1); } /* Ouverture du nouveau fichier en criture */ OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); exit(-1); } /* Saisie de l'enregistrement insrer */ printf("Enregistrement ajouter : \n"); printf("Numro de matricule : "); scanf("%d",&MATRI_NOUV); printf("Nom : "); scanf("%s",NOM_NOUV); printf("Prnom : "); scanf("%s",PRE_NOUV); /* Copie des enregistrements dont le nom */ /* prcde lexicogr. celui insrer. */ TROUVE = 0; while (!feof(INFILE) && !TROUVE) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); if (strcmp(NOM, NOM_NOUV) > 0) TROUVE = 1; else fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM); } Page 207 sur 217

Module Langage de programmation structure


/* Ecriture du nouvel enregistrement, */ fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV); /* et du dernier enregistrement lu. */ if (TROUVE) fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); /* Copie du reste des enregistrements */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM); } /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; }

5. Exercice 5
a) Supprimer les enregistrements, dont le numro de matricule se termine par 8 #include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[] = "A:\\INFORM.TXT"; char NOUVEAU[] = "A:\\INFBIS.TXT"; FILE *INFILE, *OUTFILE; /* Autres variables */ char NOM[30], PRENOM[30]; int MATRICULE; /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN, "r"); if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); exit(-1); } /* Ouverture du nouveau fichier en criture */ OUTFILE = fopen(NOUVEAU, "w"); Page 208 sur 217

Module Langage de programmation structure


if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); exit(-1); } /* Copie de tous les enregistrements l'exception */ /* de ceux dont le numro de matricule se termine */ /* par 8. */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); if (MATRICULE%10 != 8) fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM); } /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; } b) Supprimer les enregistrements, dont le prnom est "Paul" (utiliser strcmp) #include <stdio.h> #include <stdlib.h> #include <string.h> main() { /* Dclarations */ ... /* Ouverture de l'ancien fichier en lecture */ ... /* Ouverture du nouveau fichier en criture */ ... /* Copie de tous les enregistrements l'exception */ /* de ceux dont le prnom est 'Paul'. */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); if (strcmp(PRENOM,"Paul") != 0) fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM); } /* Fermeture des fichiers */ ... } c) Supprimer les enregistrements, dont le nom est un palindrome. Dfinir une fonction d'aide PALI qui fournit le rsultat 1 si la chane transmise comme paramtre est un palindrome, sinon la valeur zro. #include <stdio.h> #include <stdlib.h> Page 209 sur 217

Module Langage de programmation structure


main() { /* Prototype de la fonction PALI */ int PALI(char *CH); /* Dclarations */ ... /* Ouverture de l'ancien fichier en lecture */ ... /* Ouverture du nouveau fichier en criture */ ... /* Copie de tous les enregistrements l'exception */ /* des palindromes. */ while (!feof(INFILE)) { fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM); if (!PALI(NOM)) fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM); } /* Fermeture des fichiers */ ... } int PALI(char *CH) { /* Variable locale */ char *CH2; /* Placer CH2 la fin de la chane */ for (CH2=CH; *CH2; CH2++) ; CH2--; /* Contrler si la chane dsigne par CH est un palindrome */ for (; CH<CH2; CH++,CH2--) if (*CH != *CH2) return 0; return 1; }

6. Exercice 6
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Nom du fichier et pointeur de rfrence */ char NOM_FICH[] = "A:\\FAMILLE.TXT"; FILE *FICHIER; /* Autres variables */ Page 210 sur 217

Module Langage de programmation structure


char NOM[30], PERE[30], MERE[30], ENFANT[30]; int J,N_ENFANTS; int I,N_ENR; /* Ouverture du nouveau fichier en criture */ FICHIER = fopen(NOM_FICH, "w"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Saisie des donnes et cration du fichier */ printf("*** Cration du fichier %s ***\n", NOM_FICH); printf("Nombre d'enregistrements crer : "); scanf("%d",&N_ENR); for (I=1; I<=N_ENR; I++) { printf("Enregistrement No: %d \n", I); printf("Nom de famille : "); scanf("%s", NOM); printf("Prnom du pre : "); scanf("%s", PERE); printf("Prnom de la mre : "); scanf("%s", MERE); printf("Nombre d'enfants : "); scanf("%d", &N_ENFANTS); fprintf(FICHIER, "%s\n%s\n%s\n%d\n", NOM, PERE, MERE, N_ENFANTS); for (J=1; J<=N_ENFANTS; J++) { printf("Prnom %d. enfant : ", J); scanf("%s", ENFANT); fprintf(FICHIER, "%s\n", ENFANT); } } /* Fermeture du fichier */ fclose(FICHIER); /* Rouverture du fichier */ FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Affichage du fichier */ printf("*** Contenu du fichier %s ***\n", NOM_FICH); Page 211 sur 217

Module Langage de programmation structure


while (!feof(FICHIER)) { fscanf (FICHIER, "%s\n%s\n%s\n%d\n", NOM, PERE, MERE, &N_ENFANTS); printf("\n"); printf("Nom de famille : %s\n", NOM); printf("Nom du pre : %s %s\n", PERE, NOM); printf("Nom de la mre : %s %s\n", MERE, NOM); printf("Noms des enfants : \n", N_ENFANTS); for (J=1; J<=N_ENFANTS; J++) { fscanf(FICHIER, "%s\n", ENFANT); printf("\t%d. : %s %s\n", J, ENFANT, NOM); } } /* Fermeture du fichier */ fclose(FICHIER); return 0; }

7. Exercice 7
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Nom du fichier et pointeur de rfrence */ char NOM_FICH[] = "A:\\MOTS.TXT"; FILE *FICHIER; /* Autres variables */ char CHAINE[50]; /* Ouverture du nouveau fichier en criture */ FICHIER = fopen(NOM_FICH, "w"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Saisie des donnes et cration du fichier */ printf("*** Cration du fichier %s ***\n", NOM_FICH); do { printf("Entrez un mot ('*' pour finir) : "); scanf("%s", CHAINE); if (CHAINE[0] != '*') fprintf(FICHIER, "%s\n", CHAINE); Page 212 sur 217

Module Langage de programmation structure


} while (CHAINE[0] != '*'); /* Fermeture du fichier */ fclose(FICHIER); return 0; }

8. Exercice 8
#include <stdio.h> #include <stdlib.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char NOM_FICH[] = "A:\\NOMBRES.TXT"; FILE *FICHIER; /* Autres variables */ int NOMBRE; /* nombre actuel lu dans le fichier */ int N; /* compteur des nombres */ long SOMME; /* somme des nombres */ /* Ouverture de l'ancien fichier en lecture */ FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); exit(-1); } /* Lecture du fichier et comptabilit */ N=0; SOMME=0; while (!feof(FICHIER)) { fscanf (FICHIER, "%d\n", &NOMBRE); SOMME += NOMBRE; N++; } /* Fermeture du fichier */ fclose(FICHIER); /* Affichage des rsultats */ printf("Le fichier %s contient %d nombres.\n", NOM_FICH, N); printf("La somme des nombres est : %ld\n", SOMME); printf("La moyenne des nombres est : %f\n", (float)SOMME/N); return 0; }

Page 213 sur 217

Module Langage de programmation structure


9. Exercice 9
#include <stdio.h> main() { /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char ANCIEN[30], NOUVEAU[30]; FILE *INFILE, *OUTFILE; /* Autres variables */ char C; /* caractre lu dans le fichier */ char N_RET; /* Compteur des retours la ligne conscutifs */ /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier source : "); scanf("%s", ANCIEN); INFILE = fopen(ANCIEN, "r"); if (!INFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", ANCIEN); } while (!INFILE); /* Ouverture du nouveau fichier en criture */ do { printf("Nom du nouveau fichier : "); scanf("%s", NOUVEAU); OUTFILE = fopen(NOUVEAU, "w"); if (!OUTFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOUVEAU); } while (!OUTFILE); /* Copier tous les caractres et remplacer le */ /* premier retour la ligne d'une suite par */ /* un espace. */ N_RET=0; while (!feof(INFILE)) { C=fgetc(INFILE); if (!feof(INFILE)) { if (C == '\n') { Page 214 sur 217

Module Langage de programmation structure


N_RET++; if (N_RET > 1) fputc('\n', OUTFILE); else fputc(' ', OUTFILE); } else { N_RET=0; fputc(C, OUTFILE); } }

} /* Fermeture des fichiers */ fclose(OUTFILE); fclose(INFILE); return 0; } Remarque :

Aprs la lecture par fgetc, il faut s'assurer encore une fois que le caractre lu est diffrent de EOF. Nous obtenons ainsi une construction un peu lourde: while (!feof(INFILE)) { C=fgetc(INFILE); if (!feof(INFILE)) { ... } } Il est possible de runir plusieurs instructions dans le bloc conditionnel de la structure while, en les sparant par des virgules. En pratique, on retrouve cette solution souvent pour viter des constructions inutilement lourdes: while (C=fgetc(INFILE), !feof(INFILE)) { ... }

10. Exercice 10
#include <stdio.h> main() { /* Prototype de la fonction FIN_PHRASE */ int SEPA(char C); /* Dclarations : */ /* Noms des fichiers et pointeurs de rfrence */ char NOM_FICH[30]; FILE *FICHIER; Page 215 sur 217

Module Langage de programmation structure

/* Autres variables */ char C; /* caractre lu dans le fichier */ int ABC[26]; /* compteurs des lettres de l'alphabet */ int NTOT; /* nombre total des caractres */ int NAUTRES; /* nombre des caractres qui ne font pas partie de l'alphabet */ int NMOTS; /* nombre des mots */ int NPARA; /* nombre de paragraphes (retours la ligne) */ int I; /* indice d'aide */ int DANS_MOT; /* indicateur logique: */ /* vrai si la tte de lecture se trouve */ /* actuellement l'intrieur d'un mot. */ /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier texte : "); scanf("%s", NOM_FICH); FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); } while (!FICHIER); /* Initialisations des variables */ for (I=0; I<26; I++) ABC[I]=0; NTOT =0; NAUTRES =0; NMOTS =0; NPARA =0; DANS_MOT=0; /* Examination des caractres du fichier */ while (!feof(FICHIER)) { C=fgetc(FICHIER); if (!feof(FICHIER)) { /* Comptage au niveau caractres */ if (C=='\n') NPARA++; else { NTOT++; if (C>='a' && C<='z') ABC[C-'a']++; else if (C>='A' && C<='Z') ABC[C-'A']++; Page 216 sur 217

Module Langage de programmation structure


else NAUTRES++; } /* Comptage des mots */ if (SEPA(C)) { if (DANS_MOT) { NMOTS++; DANS_MOT=0; } } else DANS_MOT=1; }

} /* Fermeture du fichier */ fclose(FICHIER); /* Affichage du rsultat */ printf("Votre fichier contient :\n"); printf("\t%d paragraphes\n", NPARA); printf("\t%d mots\n", NMOTS); printf("\t%d caractres\ndont\n", NTOT); for (I=0; I<26; I++) printf("\t%d fois la lettre %c\n", ABC[I], 'a'+I); printf("et %d autres caractres\n", NAUTRES); return 0; } int SEPA(char C) { /* Tableau contenant tous les sparateurs de mots */ char SEP[12] = { '\n', ' ', ',', ';', '.', ':', '?', '!', '(', ')', '"', '\'' }; int I; /* Comparaison de C avec tous les lments du tableau */ for (I=0 ; C!=SEP[I] && I<12 ; I++) ; if (I==12) return 0; else return 1; /* ou bien simplement : */ /* return (I != 12); */ } Page 217 sur 217

Vous aimerez peut-être aussi