Table des matières

1 Fichiers 2
1 Contenu de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Fichier séquentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 Buffer( mémoire tampon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
4 Manipulation de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
4.1 Déclaration et liaison de fichier . . . . . . . . . . . . . . . . . . . . . 4
4.2 mode d’ouverture de fichier . . . . . . . . . . . . . . . . . . . . . . . 5
4.3 Lecture/ écriture dans un fichier . . . . . . . . . . . . . . . . . . . . . 5
4.4 Fermeture de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5 Les fichiers En langage C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
6 Ouverture/ création de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 5
6.1 Fermeture de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
7 Fin de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
8 Lecture et écriture dans un fichier texte . . . . . . . . . . . . . . . . . . . . . 7
8.1 Lecture de fichier texte . . . . . . . . . . . . . . . . . . . . . . . . . . 7
8.2 Écriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 9
8.3 Lecture et écriture dans un fichier binaire . . . . . . . . . . . . . . . . 11
8.4 Écriture dans un fichier binaire . . . . . . . . . . . . . . . . . . . . . 11
8.5 Lecture de fichier binaire . . . . . . . . . . . . . . . . . . . . . . . . . 13
8.6 Suppression d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 14
8.7 Autres fonctions pour fichiers . . . . . . . . . . . . . . . . . . . . . . 15
8.8 rewind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.9 ftell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.10 fseek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.11 rewing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.12 Gestion des erreurs en C . . . . . . . . . . . . . . . . . . . . . . . . . 16
8.13 errno, perror et strerror . . . . . . . . . . . . . . . . . . . . . . . . . 16
8.14 Statut de fin du programme . . . . . . . . . . . . . . . . . . . . . . . 17

1
Chapitre 1

Fichiers

Un fichier informatique est une ressource informatique pour enregistrer des données dis-
crètement dans un support de stockage(disque dur, cdrom, clé usb ...). Tout comme les mots
peuvent être écrits sur papier, les données peuvent être écrites dans un fichier. Les fichiers
peuvent être modifiés et transférés via Internet sur ce système informatique particulier.
Il existe différents types de fichiers, conçus pour différentes finalités. Un fichier peut
être conçu pour stocker une image, un texte, une vidéo, un programme informatique ou
d’autres variétés de types de données. Certains types de fichiers peuvent stocker plusieurs
types d’informations à la fois.
En utilisant des programmes informatiques, on peut ouvrir, lire, modifier, enregistrer et
fermer un fichier. Les fichiers peuvent être rouverts, modifiés et copiés un nombre arbitraire
de fois.
En règle générale, les fichiers sont organisés dans un système de fichiers, qui garde la
trace de l’emplacement des fichiers sur le disque et permet l’accès des utilisateurs.

1 Contenu de fichier
Sur la plupart des systèmes d’exploitation modernes, les fichiers sont organisés en ta-
bleaux unidimensionnels d’octets. Le format d’un fichier est défini par son contenu car un
fichier est vu comme un conteneur de données, bien que sur certaines plate-formes le format
soit généralement indiqué par son extension de nom de fichier( jpg, bmp, mp3 ...), spécifiant
les règles sur la façon dont les octets doivent être organisés et interprétés de manière signi-
ficative. Par exemple, les octets d’un fichier texte brut (.txt dans Windows) sont associés à
des caractères ASCII ou UTF-8, tandis que les octets des fichiers image, vidéo et audio sont
interprétés autrement.
Certains systèmes de fichiers peuvent stocker des données spécifiques au fichier arbitraires
(non interprétées par le système de fichiers) en dehors du format de fichier, par exemple des
attributs étendus. Sur d’autres systèmes de fichiers, cela peut être fait via des bases de
données spécifiques au logiciel. Cependant, toutes ces méthodes sont plus susceptibles de
perdre des métadonnées que les formats de fichier conteneur et archive.
L’utilisation des fichiers dans notre vie quotidienne devient implicite vu l’utilisation des
nouvelles technologies comme smart-phones ordinateur et divers dispositifs. Un fichier étant

2
un outils de sauvegarde de différentes données (image, vidéo, son, texte ...) est identifié
par un nom et nécessite une place dans la mémoire auxilière qui un espace de stockage
comme disque dur, clé us, dvdrom, réseau ... L’emplacement du fichier est un chemin d’accès
permettant atteindre le fichier. Contrairement au concept précédent, après la fin d’exécution
de programme les données disparaissent de la mémoire et ne peuvent pas être stocker que
par l’utilisation de fichier. Donc, l’utilisation de fichier permet de retenir les données pour
les utiliser lors du besoin.

Exemple de fichier : Si on a une chaîne de 100 caractères et on veut la stocker dans un

fichier, on utilise un fichier texte.

2 Fichier séquentiel
Dans les fichiers séquentiels, les enregistrements sont placées en mémoire consécutivement
leur ordre chronologique d’entrée et peuvent être lus dans cet ordre. Si on a besoin de
consulter un enregistrement précis dans un fichier, il passer séquentiellement sur tous les
enregistrements qui, en commençant par le premier.

3 Buffer( mémoire tampon

une mémoire tampon(buffer), est une zone de mémoire vive ou de disque utilisée pour
placer des données temporaires, deux processus ou entre matériels qui se différencie en vitesse.
Donc, elle a le rôle de réduire le nombre d’accès aux périphériques, ainsi que le mouvement
de la tête de lecture/écriture.

4 Manipulation de fichiers
pour qu’un programme utilise un fichier, on a besoin d’un certain nombre d’informations
du fichier :
— Le nom et le chemin d’accès au fichier
— position actuelle de la tête de lecture/écriture,
— type d’accès au fichier : écriture, lecture...
— erreur de manipulation si elle existe( ouverture d’un fichier inexistant, chemin incorrect
...)
Toutefois, il faut faire la différence entre le fichier logique et le fichier physique. Le fichier
logique est celui utilise par le programme et lié par l’entité physique (le fichier sauvegardé
sur le support physique), il est manipulé dans la mémoire vive. L’opération de transfère
ou de chargement est renseignée au système par une instruction d’assignation établir une
liaison entre le fichier logique F en mémoire et le chemin d’accès du fichier sur le support
physique, dans le cas ou la liaison échoue une erreur d’entrée / sortie est déclenchée parce
que le système ne peut savoir ou lire ou écrire.

3
 4.1 Déclaration et liaison de fichier
Pour déclarer un fichier dans un algorithme, on doit spécifier le type de fichier. Par
exemple :

1 F : fichier texte
2 F1 : fichier d’entier
3 F2 : Fichier d’étudiants //étudiant est un enregistrement.

En langage C : La déclaration d’un fichier dans le langage C est faite par le biais de
pointeur vers une variable FILE, l’exemple 1.1 illustre un code complet qui permet d’ouvrir
un fichier en mode lecture et affiche son contenu.
Listing 1.1 – Déclaration de fichier
1 # include < stdio .h >
2 # include < string .h >
3
4 int main ( )
5 {
6 FILE * f ; // De é clarer un pointeur vers le fichier f
7 char data [50]= " Ceci est un exemple de texte vers un fichier " ;
8 f = fopen ( " GfgTest . c " , " w " ) ;
9 if ( f == NULL ) // ( f == NULL ) <= > ( f )
10 {
11 printf ( " d :\\ testF . txt : erreur d ’ ouverture de fichier . " ) ;
12 }
13 else
14 {
15 printf ( " Fichier ouvert \ n " ) ;
16 // é crire data dans le fichier F
17 if ( strlen ( data ) > 0) // si la cha ê ne n ’ est pas vide
18 {
19
20 // É crire dans le fichier par l ’ instruction fputs
21 fputs ( data , f );
22 fputs ( " \ n " , f );
23 }
24
25 // fermeture de fichier F fclose ()
26 fclose ( f ) ;
27 printf ( " É criture dans le fichier testF . txt avec sucss è s \ n " );
28 printf ( " Fichier ferme " ) ;
29 }
30 return 0;
31 }

4
 Dans cet exemple, on veut écrire la chaîne de caractère data dans le fichier physique identifié
par son nom : "testF.txt" qui se situe dans l’emplacement : lecteur "d :". Pour ouvrir un
fichier, on utilise l instruction "fopen", elle permet de faire la liaison entre le pointeur F est
le fichier physique "testF.txt". La liaison entre les deux entités permet d’affecter l’adresse
retournée par "fopen" au pointeur F. dans cette exemple le mode d’ouverture est "w" qui est
le mode écriture. l’instruction "fopen" en mode écriture, si l’opération est réussite, permet de
créer un fichier dans l’emplacement spécifié, dans ce cas "d :", si ’il n’existe pas et d’écraser
le contenu du fichier si il existe. L’instruction "fputs(data, F)" permet d’écrire la chaîne de
caractère data dans le fichier F. Après l’utilisation du fichier F, il faut toujours le fermer.
Dans le cas échéant, une erreur système est retourné indiquant que l’ouverture n’a pas eu
lieu.

4.2 mode d’ouverture de fichier

4.3 Lecture/ écriture dans un fichier
4.4 Fermeture de fichier

5 Les fichiers En langage C

5.1 Déclaration
Un fichier sous C est déclaré comme un pointeur qui communique entre le fichier physique
et le programme, en utilisant le mot clé FILE (Comme le langage c est sensible à la casse,
File doit être en Majuscule). En plus, le langage C ne fait pas la différence entre fichiers
textes et fichiers binaires dans la déclaration.
1 File * ptr ;

6 Ouverture/ création de fichier

Pour ouvrir, modifier ou créer un fichier on utilise la fonction de la bibliothèque standard
d’entrée/sortie stdio.h : fopen, avec la syntaxe suivante :
1 ptr = fopen ( " chemin_d ’ acc è s \ nom_du_fichier " , " mode " );

— Le chemin d’accès est une variable de type chaîne de caractères qui contient l’empla-
cement physique du fichier, il peut être un lecteur optique, une clé usb ou un lecteur
logique de disque dur.
— Le nom du fichier est une variable de type chaîne de caractères indiquant le nom du
fichier (dans le cas de Windows, on utilise l’extension de fichier : texte : txt, binaire :
bin ...).
— Le mode indique la façon dont on ouvert le fichier (lecture, écriture ...), comme illustré
dans la table 1.1.

5
 l’ouverture de fichier avec la fonction fopen permet d’ouvrir le fichier et positionner le
pointeur au début du fichier dans le cas d’ouverture en mode lecture (r, rb), écriture (w, wb)
ou lecture/écriture (rw, r+, w+, rb+, wb+), et de positionner le pointeur à la fin dans le cas
du ajout (a, ab, a+, ab+.

Mode Signification Comportement d’éxistance de fichier

r Ouverture en lecture Si le fichier n’éxiste pas, fopen() re-
tourne NULL.
rb Ouverture en mode lecture binaire Si le fichier n’éxiste pas, fopen() re-
tourne NULL.
w Ouverture en creat Si le fichier existe, il sera effacé. Et créé
Sinon
wb Ouverture en mode écriture binaire Si le fichier existe, il sera effacé. Et créé
Sinon
a Ouverture en mode ajout (l’ajout se fait Si le fichier n’éxiste pas, il sera créé
à la fin)
ab Ouverture en mode ajout bi- Si le fichier n’éxiste pas, il sera créé
naire(l’ajout se fait à la fin)
r+ Ouverture en mode lecture/écriture Si le fichier n’éxiste pas, fopen() re-
tourne NULL.
rb+ Ouverture en mode lecture/écriture bi- Si le fichier n’éxiste pas, fopen() re-
naire tourne NULL.
w+ Ouverture en mode lecture/création Si le fichier n’éxiste pas, il sera créé
wb+ Ouverture en mode lecture/création bi- Si le fichier n’éxiste pas, il sera créé
naire
a+ Ouverture en mode lecture/ajout Si le fichier n’éxiste pas, il sera créé
ab+ Ouverture en mode lecture/ajout bi- Si le fichier n’éxiste pas, il sera créé
naire.

Table 1.1 – Mode d’ouverture

Si il y’a un problème d’ouverture de fichier, la fonction fopen retourne NULL, le cas
échéant la fonction retourne une valeur différente : dans notre exemple ptr 6= N U LL.
1 FILE * texte , * binaire ,
2 texte = fopen ( " E :\\ test \\ texte . txt " ," w " ); // exemple 01
3 binaire = fopen ( " E :\\ test \\ bexiste . bin " ," rb " ); // exempel 02

Exemple 01 : Le premier fichier est ouvert en mode écriture "w", donc s’il existe, il sera
écrasé. Sinon la fonction fopen permet de créer un fichier qui s’appelle texte.txt situé dans
le répertoire ”e : \test”.

Exemple 02 : Le deuxième fichier est ouvert en mode lecture "r" et le mode binaire
en même temps "b", la fonction fopen retourne NULL si le fichier bexiste.bin situé dans
l’emplacement physique ”e : \test” n’existe pas ou il y’a une erreur d’ouverture de fichier.
Sinon il est ouvert en mode lecture binaire.

6
 Remarque : Dans le mode lecture il n’est pas possible d’écrire dans le fichier.

6.1 Fermeture de fichier

Après la manipulation d’un fichier, il doit être fermé pour conserver son intégralitén car
un fichier qui n’a pas été fermé risque de l’endommager. Pour fermer un fichier, on utilise la
fonction fclose de la bibliothèque standard d’entrée/sortie stdio.h par la syntaxe suivante :
1 fclose ( ptr ); // ptr d é signe le fichier a fermer .

7 Fin de fichier
Une autre fonction très importante dans la manipulation de fichiers est le test de fin
de fichier, elle retourne vrai si le pointeur du fichier est à la fin du fichier et faux dans le
cas échéant. En langage C, la fonction utilisée estfeof(FILE *ptr. Un exemple illustre son
fonctionnement dans le code 1.4

8 Lecture et écriture dans un fichier texte

Pour lire un fichier ou écrire dans un fichier, il existe plusieurs fonctions standards qui
permettent la lecture ou l’écriture dans un fichier :
— fscanf /fprintf
— fgets /fputs
— fgetc /fputc

Remarque :
— Dans les codes en C qui suivent, on utilise le lecteur c : \, il faut exécuter codeblocks
en tant qu’ administrateur, mais vous pouvez changer le chemin du fichier vers une clé
usb par exemple.
— Si on ne donne pas le chemin d’accès du fichier, le programme prend son propre chemin
d’accès(si le programme est enregistrer dans le lecteur d : \ alors le fichier sera dans la
même location.

8.1 Lecture de fichier texte

fscanf
on utilise la fonction de la bibliothèque standard stdio.h : fscanf qui est une version fi-
chier de la fonction d’entrée/sortie standard scanf seulement que la fonction fscanf exigent
le fichier source de lecture
Listing 1.2 – Exemple d’utilisation de fscanf.
1 include < stdio .h >

7
 2 # include < stdlib .h >
3
4 int main ()
5 {
6 int num ;
7 FILE * ptr ; // D é claration du fichier
8 if (( ptr = fopen ( " C :\\ test . txt " ," r " )) == NULL ){
9 printf ( " Erreur d ’ ouverture de fichier " );
10 exit (1);
11 // Le programme s ’ arrete si le le pointeur de
12 // fichier retourne NULL
13 }
14
15 fscanf ( ptr , " % d " , & num );
16 /* Lire a partir du fichier ptr avec un formattage entier
17 et le mettre dans la variable num n = contenu de la
18 position du pointeur ptr */
19
20 printf ( " Value of n =% d " , num ); // Afficher la variable num
21 fclose ( ptr ); // fermer le fichier
22
23 return 0;
24 }

fgets
la fonction fgets : char *fgets(char *s, int n, FILE *ptr) lit une ligne du fichier
spécifié et la stocke dans une chaîne pointée par s de taille n. elle s’arrête lorsque l’un des
caractères (n-1) est lu, le caractère de nouvelle ligne ou la fin du fichier atteint.
Listing 1.3 – Exemple d’utilisation de fgetsc.
1 # include < stdio .h >
2 int main () {
3 FILE * ptr ;
4 char str [60];
5 // ouverture en mode lecture
6 fp = fopen ( " test . txt " , " r " );
7 // En cas d ’ erreur
8 if ( fp == NULL ) {
9 perror ( " Erreur : " );
10 return ( -1);
11 }
12 // Si fgets n ’ est pas NULL
13 if ( fgets ( str , 60 , fp )!= NULL ) {
14 puts ( str );

8
15 }
16 fclose ( fp );
17 return (0);
18 }

fgetc
La fonction fgetc : int fgetc(FILE *ptr) cette fonction lit le fichier par caractère, elle
récupère le caractère suivant (un caractère non signé) du fichier spécifié et avance le pointeur
du fichier.
Listing 1.4 – Exemple d’utilisation de fgetc.
1 # include < stdio .h >
2 int main () {
3 FILE * fp ;
4 int c ;
5 int n = 0;
6 fp = fopen ( " c :\\ test . txt " ," r " );
7 if ( fp == NULL ) {
8 perror ( " Erreur d ’ ouverture de fichier " );
9 return ( -1);
10 }
11 do {
12 c = fgetc ( fp ); // lire le fichier caract è re par caract è re
13 if ( feof ( fp )){ // on s ’ arr ê te jusqu ’à la fin du fichier
14 break ;
15 }
16 printf ( " % c " , c );
17 } while (1);
18 fclose ( fp );
19 return (0);
20 }

8.2 Écriture dans un fichier

fprintf
Écrit une chaîne de caractères pointée par le format dans le fichier. Si le format inclut des
spécificateurs de format (sous-séquences commençant par %), les paramètres supplémentaires
suivant le format sont formatés et insérés dans la chaîne résultante, en remplacement leurs
spécificateurs respectifs.
Listing 1.5 – Exemple de fprintf
1 # include < stdio .h >
2 int main ()

9
 3 {
4 FILE * ptr ;
5 int n ;
6 char name [100];
7 // ouverture de fichier en mode cr é ation
8 ptr = fopen ( " c :\\ test . txt " ," w " );
9 // Une boucle qui permet de é crire dans le fichier
10 // trois nom introduits par l ’ utilisateur
11 for ( n =0 ; n <3 ; n ++)
12 {
13 puts ( " Enter un nom : " );
14 gets ( name );
15 // é crire dans le fichier
16 fprintf ( ptr , " Nom % d :% s \ n " ,n +1 , name );
17 }
18 fclose ( ptr );
19 return 0;
20 }

fputs
La fonction copie à partir de l’adresse spécifiée jusqu’à atteindre le caractère nul final
(’/0’). Ce caractère nul final n’est pas copié dans le fichier.
Notez que fputs diffère non seulement des puts dans le sens où le flux de destination peut
être spécifié, maisfputs n’écrit pas de caractères supplémentaires, tandis que puts ajoute
automatiquement un caractère de nouvelle ligne à la fin.
Listing 1.6 – Exemple de puts
1 # include < stdio .h >
2 int main ()
3 {
4 FILE * ptr ;
5 char sentence [256];
6 printf ( " Entrer une phrase a ajouter : " );
7 // lire une cha ê ne vers l ’ entr é e standard
8 // stdin ( qui est un fichier )
9 fgets ( sentence ,256 , stdin );
10 // ouverture de fichier en mode ajout
11 ptr = fopen ( " c :\\ test . txt " ," a " );
12 if ( ptr == NULL ) {
13 perror ( " Erreur d ’ ouverture de fichier " );
14 return ( -1);
15 }
16 // é crire la cha ê ne de caract è re
17 // a la fin du fichier

10
18 fputs ( sentence , ptr );
19
20 fclose ( ptr );
21 return 0;
22 }

fputc
La fonction fputc écrit un seul caractère à la position indiquée par le pointeur du fichier,
qui est automatiquement avancé de un. Ainsi, cette fonction écrit dans le fichier caractère
par caractère.
Listing 1.7 – Exemple de fputc
1 # include < stdio .h >
2 int main ()
3 {
4 FILE * ptr ;
5 char c ;
6 // ouverture en mode cr é ation
7 ptr = fopen ( " c :\\ test . txt " ," w " );
8 if ( ptr != NULL ) {
9 for ( c = ’A ’ ; c <= ’Z ’ ; c ++)
10 // é crire le caract è re c dans le fichier ptr
11 fputc ( c , ptr );
12 fclose ( ptr );
13 }
14 return 0;
15 }

8.3 Lecture et écriture dans un fichier binaire

Pour manipuler un fichier binaire on utilise principalement deux fonctions fread pour la
lecture et fwrite pour l’écriture dans le fichier.

8.4 Écriture dans un fichier binaire

Pour écrire dans un fichier binaire, on doit utiliser la fonction fwrite. La fonction prend
quatre paramètres : adresse des données à écrire sur le disque, taille des données à écrire
dans le fichier, nombre de ce type de données et pointeur vers le fichier où on doit écrire.
Listing 1.8 – Fonction fwrite
1 fwrite ( Adr1 , Size , Num , ptr );
2 // Adr1 : adresse de donn é es a é crire
3 // Size : taille de donn é es a é crire
4 // Num : nombre d ’é l é ment a é crire

11
5 // ptr : pointeur de fichier

Remarque : Dans le cas du fichier binaire, et contrairement au fichier texte, il est impos-
sible de lire un fichier binaire par un éditeur de texte. Il faut impérativement le lire par un
programme.
Listing 1.9 – exemple de fwrite
1 # include < stdio .h >
2 # include < stdlib .h >
3 // D é finir un enregistrement compose de trois entiers
4 struct Records
5 {
6 char nom [30];
7 int n1 , n2 , n3 ;
8 };
9 int main (){
10 int n ;
11 struct Records num ;
12 FILE * ptr ;
13 // Ouverture de fichier binaire en mode cr é ation binaire
14 if (( ptr = fopen ( " C :\\ program . bin " ," wb " )) == NULL ){
15 printf ( " Erreur ! ouverture de fichier " );
16 exit (1);
17 }
18 // é crire dans le fichier 5 enregistrements
19 for ( n = 1; n < 5; ++ n ){
20 gets ( nom );
21 num . n1 = n ;
22 num . n2 = 5* n ;
23 num . n3 = 5* n + 1;
24 fwrite (& num , sizeof ( struct Records ) , 1 , ptr );
25 }
26 fclose ( ptr );
27 return 0;
28 }
Dans cet exemple on définit un enregistrement composé de trois entier n1, n2 et n3, en
entrant dans la boucle, l’affectation des valeurs de chaque champs de l’enregistrement est
faite par rapport de la valeur de n allant de 1-5. fwrite écrit dans l’adresse de l’enregistrement
num, avec la même taille de l’enregistrement, 1 désigne qu’on écrit un seul élément dans le
fichier c-à-d un seul enregistrement et enfin le pointeur du fichier.
Un autre exemple de fwrite, ou on montre le changement du paramètre nombre éléments.
Listing 1.10 – Utilisation fwrite
1 # include < stdio .h >

12
 2 # include < stdlib .h >
3 enum { SIZE = 5 };
4 int main ( void )
5 {
6 int a [ SIZE ] = {1 , 2 , 3 , 4 , 5};
7 FILE * f1 = fopen ( " fichier . bin " , " wb " );
8 // fwrite é crit dans le fichier
9 size_t r1 = fwrite (a , sizeof a [0] , SIZE , f1 );
10
11 // % lu design le formatage pour afficher une taille size_t
12 printf ( " É crire % lu é l é ments de % d demand é s \ n " , r1 , SIZE );
13
14 fclose ( f1 );
15
16 int b [ SIZE ];
17 FILE * f2 = fopen ( " file . bin " , " rb " );
18 size_t r2 = fread (b , sizeof b [0] , SIZE , f2 );
19 fclose ( f2 );
20 printf ( " relecture : " );
21 for ( size_t i = 0; i < r2 ; i ++)
22 printf ( " % d " , b [ i ]);
23 }
Dans cet exemple, on écrit le tableau a de 5 éléments dans le fichier f1. On remarque que
nombre de données à écrire dans le fichier est égale à SIZE=5 alors que dans le cas de
l’exemple précédant la valeur était 1. cela signifie que que cette fonction écrit SIZE éléments
de taille b[0] le tableau a dans le fichier f1, en d’autres termes, les 5 valeurs du tableau a.

8.5 Lecture de fichier binaire

Comme la fonction fwrite, la fonction fread prend également quatre paramètres, sauf
que cette fonction permet de lire les données à partir d’un fichier.
Listing 1.11 – Fonction fread
1 fread ( Adr1 , Size , Num , ptr );
2 // Adr1 : adresse de donn é es a lire
3 // Size : taille de donn é es a lire
4 // Num : nombre d ’é l é ment a lire
5 // ptr : pointeur de fichier

Listing 1.12 – exemple de fread

1
2 # include < stdio .h >
3 # include < stdlib .h >
4
5 struct Records

13
 6 {
7 char nom [30];
8 int n1 , n2 , n3 ;
9 };
10 int main ()
11 {
12 int n ;
13 struct Records num ;
14 FILE * ptr ;
15
16 if (( ptr = fopen ( " C :\\ program . bin " ," rb " )) == NULL ){
17 printf ( " Erreur ! d ’ ouverture du fichier " );
18 // arret du programme en cas d ’é chec d ’ ouverture .
19 exit (1);
20 }
21 for ( n = 1; n < 5; ++ n )
22 {
23 fread (& num , sizeof ( struct Records ) , 1 , ptr );
24 printf ( " nom : % s \ n " , num . nom );
25 printf ( " n1 : % d \ tn2 : % d \ tn3 : % d \ n \ n " , num . n1 , num . n2 , num . n3 );
26 }
27 fclose ( ptr );
28 return 0;
29 }
Dans le listing 1.12, on lit le même fichier du code 1.10 et parcourir les enregistrements
un par un. On lit un enregistrement records de taille records à parti du fichier pointé par
*ptr dans la structure num. On obtient les mêmes enregistrements qu’on a insérés dans le
programme 1.10.

Remarques :
— On peut utiliser fread/fwrite pour manipuler un fichier texte. Comme un exercice de
pratique, essayez de manipuler un fichier texte avec les deux fonctions fread/fwrite.
— La structure de fichier est définie par la façon d’écriture dans le fichier et non pas par
sa déclaration.

8.6 Suppression d’un fichier

La fonction de suppression en C peut être utilisée pour supprimer un fichier. La fonction
renvoie 0 si les fichiers sont supprimés avec succès, sinon elle renvoie une valeur non nulle.
1 # include < stdio .h >
2 int main ()
3 {
4 if ( remove ( " abc . txt " ) == 0)

14
5 printf ( " Suppression avec succ è s " );
6 else
7 printf ( " Impossible de supprimer le fichier " );
8 return 0;
9 }

8.7 Autres fonctions pour fichiers

8.8 rewind
C’est une fonction de rembobinage qui permet de positionner le pointeur du fichier au
début. Il faut savoir que l’utilisation de cette fonction n’est pas toujours apprécié, car il n’y
a aucun moyen de vérifier si le rembobinage a réussi.
1 void rewind ( FILE * fp )

8.9 ftell
La fonction ftell est utilisée pour obtenir la position actuelle du pointeur de fichier. Dans
un programme C, nous utilisons ftell () comme ci-dessous.
1 long int ftell ( FILE * fp )

8.10 fseek
La fonction fseek est utilisée pour positionner le pointeur de fichier sur un emplacement
spécifié. Il est utilisé pour écrire des données dans un fichier à l’emplacement souhaité. La
syntaxe de cette fonction comme la déclaration de ligne de code suivant qui est composée
de pointeur sur le fichier, le déplacement par rapport la position, et position définit le point
par rapport auquel le pointeur de fichier doit être déplacé. Il a trois valeurs :
— SEEK_END : indique la fin du fichier.
— SEEK_SET : indique le début du fichier.
— SEEK_CUR : indique la position actuelle du pointeur de fichier.

1 int fseek ( FILE * pointeur , long int deplacement , int position )

8.11 rewing
1 # include < stdio .h >
2 int main ()
3 {
4 FILE * fp ;
5 fp = fopen ( " test . txt " , " r " );
6 // D é placer le pointeur fp vers la fin du fichier

15
 7 fseek ( fp , 0 , SEEK_END );
8 // Afficher la position du pointeur
9 printf ( " % ld " , ftell ( fp ));
10 return 0;
11 }

8.12 Gestion des erreurs en C

La programmation en C, ne fournit pas de support direct pour la gestion des erreurs
mais comme C est un langage de programmation système, il offre un accès à un niveau
inférieur sous la forme de valeurs de retour. La plupart des appels de fonction C (ou même
Unix/Linux) renvoient -1 ou NULL en cas d’erreur et définissent un code d’erreur errno. Il est
défini comme une variable globale et indique qu’une erreur s’est produite lors de tout appel
de fonction. On peut trouver divers codes d’erreur définis dans le fichier d’en-tête <error.h>.
Un programmeur C peut donc vérifier les valeurs renvoyées et prendre les mesures appro-
priées en fonction de la valeur de retour. Il est recommandé de mettre errno à 0 au moment
de l’initialisation d’un programme. Une valeur de 0 indique qu’il n’y a pas d’erreur dans le
programme.

8.13 errno, perror et strerror

Le langage C fournit des fonctions perror et strerror qui peuvent être utilisées pour
afficher le message texte associé à errno.
— La fonction perror affiche la chaîne qu’on lui passe, suivie de deux points, d’un espace,
puis de la représentation textuelle de la valeur errno actuelle.
— La fonction strerror, qui renvoie un pointeur sur la représentation textuelle de la valeur
errno actuelle.
Dans le code suivant, on essaye de simuler une condition d’erreur et essaye d’ouvrir un
fichier qui n’existe pas. Ici, on utilise les deux fonctions pour montrer leur utilisation, mais
on peut utiliser une ou plusieurs façons d’afficher les erreurs systèmes. Un deuxième point
important à noter est que on doit utiliser le flux de fichiers stderr pour générer toutes les
erreurs.
Pour savoir les erreurs d’erno, on peut écrire un programme qui afficher les erreurs dans
une boucle allant de 1 à 131 dans le system d’exploitation Linux, et de 1 à 487 dans le system
d’exploitation windows.
1 # include < stdio .h >
2 # include < errno .h >
3 # include < string .h >
4 extern int errno ;
5 int main () {
6 FILE * pf ;
7 int errnum ;
8 pf = fopen ( " unexist . txt " , " rb " );

16
 9
10 if ( pf == NULL ) {
11 errnum = errno ;
12 fprintf ( stderr , " Valeur d ’ errno : % d \ n " , errno );
13 perror ( " Erreur affich é e par perror : " );
14 fprintf ( stderr , " Ouverture de fichier : % s \ n " , strerror ( errnum ));
15 } else {
16
17 fclose ( pf );
18 }
19
20 return 0;
21 }

8.14 Statut de fin du programme

Il est courant de quitter un programme avec une valeur EXIT_SUCCESS après une
opération réussite. Ici, EXIT_SUCCESS est une macro et elle est égale à 0.
Si un programme se termine avec une condition d’erreur, le programme devrait quitter
avec l’état EXIT_FAILURE qui est égale à -1. le programme illustre la division par Zéro et
le statut de sortie de programme
1 # include < stdio .h >
2 # include < stdlib .h >
3 main () {
4 int dividende = 20;
5 int diviseur = 5;
6 int quotient ;
7 if ( diviseur == 0) {
8 fprintf ( stderr , " Division par zero ...\ n " );
9 exit ( EXIT_FAILURE );
10 }
11 quotient = dividende / diviseur ;
12 printf ( " Valeur du quotient : % d \ n " , quotient );
13 exit ( EXIT_SUCCESS );
14 }

17