Chapitre 2 Les fichiers

1. Introduction
Jusqu’à présent, nous avons vu que les données d’un problème sont inclues dans le corp du programme
(algorithme) par les actions d’affectation (, = en C) ou sont entrées à l’exécution du programme par le
clavier (en utilisant l’action lire(), scanf() en C).
Imaginons que nous voulons écrire un programme qui permet :
 D’enregistrer : nom, prénom, adresse, note1, note2, note3, moyenne concernant 1000 étudiants ?
 Ce programme doit également permettre de consulter et de modifier ces informations ?
Ces données ne peuvent donc être inclues dans le programme, ni entrées au clavier à chaque nouvelle
exécution. Le problème qui se pose réside au niveau de la sauvegarde des données après la fermeture du
programme, les variables qui sont des cases mémoires ne répondent pas à nos besoins à cause de leur
disparition à chaque fin d’exécution.
 Les fichiers sont là pour résoudre ce problème. Ils servent à stoker des informations sur un support de
stockage (disque dur, CD Rom, flash disque, etc.) de manière permanente pour les réutiliser ultérieurement.
Alors :
Un fichier (file en anglais) est une suite d’informations, enregistrée sur un support physique (disque dur, flash
disque, CD-ROM) et repérée par un nom.
En C, un fichier est une suite d'octets. Les informations contenues dans le fichier ne sont pas forcément de
même type (un char, un int, une structure ...)
2. Organisation des fichiers
On distingue deux grandes catégories de fichiers : les fichiers textes et les fichiers binaires. Un premier grand
critère qui différencie ces deux catégories, est le suivant : le fichier est-il ou non organisé sous forme de lignes
successives ? Si oui, cela signifie vraisemblablement que ce fichier contient le même genre d'information à
chaque ligne. Ces lignes sont alors appelées des enregistrements.
Un fichier codé sous forme d'enregistrements est appelé un fichier texte, Ce type de fichier est couramment
utilisé dès lors que l'on doit stocker des informations pouvant être assimilées à une base de données.
Le second type de fichier, il rassemble les fichiers qui ne possèdent pas de structure de lignes
(d'enregistrement). Les octets, quels qu'il soient, sont écrits à la queue leu leu (les uns derrière les autres).
Ces fichiers sont appelés des fichiers binaires. Tous les fichiers qui ne codent pas une base de données sont
obligatoirement des fichiers binaires : cela concerne par exemple un fichier son, une image, un programme
exécutable, etc. . Toutefois, il est toujours possible d'opter pour une structure binaire même dans le cas où
le fichier représente une base de données. On peut définir :
 Les fichiers textes : sont les fichiers dont le contenu représente uniquement une suite de caractères
imprimables, d'espaces et de retours à la ligne (.txt,...). Ils peuvent être lus directement par un
éditeur de texte.
 Les fichiers binaires : sont les fichiers qui ne sont pas assimilables à des fichiers textes (.exe, .mp3,
.png, .doc,...). Ils ne peuvent pas être lus directement par un éditeur de texte .
3. Types d’accès
Autrement dit la manière dont la machine va pouvoir aller rechercher les informations contenues dans le
fichier. On distingue :
 L’accès séquentiel : On ne peut accéder à une information qu'en ayant au préalable examiné celle qui la
précède. Dans le cas d'un fichier texte, cela signifie qu'on lit le fichier ligne par ligne (enregistrement par
enregistrement).
 L’accès direct (ou aléatoire) : On peut accéder directement à l’enregistrement (à l’information) de son
choix, en précisant le numéro de cet enregistrement.
Chapitre 2 Les fichiers
 L’accès indexé : pour simplifier, il combine la rapidité de l'accès direct et la simplicité de l'accès séquentiel.
Il est particulièrement adapté au traitement des gros fichiers, comme les bases de données importantes.
Rq : Le langage C ne distingue pas les fichiers à accès séquentiel des fichiers à accès direct, certaines fonctions
de la bibliothèque livrée avec le compilateur permettent l'accès direct. Les fonctions standards sont des
fonctions d'accès séquentiel.
4. Opérations
Les opérations possibles avec les fichiers sont :
Créer - Ouvrir - Fermer - Lire - Ecrire - Détruire - Renommer.
La plupart des fonctions permettant la manipulation des fichiers sont rangées dans la bibliothèque standard
STDIO.H
4.1. Déclaration : FILE* fichier ; /* majuscules obligatoires pour FILE */
On définit un pointeur (*). Le pointeur fournit l'adresse d'une information quelconque.
La déclaration des fichiers doit figurer AVANT la déclaration des autres variables.
4.2. Ouvrir un fichier : cette fonction de type FILE * ouvre un fichier et lui associe un flot de données, sa
syntaxe est fopen(‘’nom de fichier ‘’, ‘’ mode ‘’);
On passe donc deux arguments de type chaînes de caractères :
 Le premier (’nom de fichier): est le nom du fichier concerné figurant sur le disque, exemple: « D
:\toto.dat » il est de préférence de définir le nom de ce fichier par une constante symbolique au
moyen de la directive #define au lieu d’expliciter ce nom dans le corp du programme, exemple
#define F D :\toto.dat
 Le second (mode) : spécifie le mode d’accès au fichier, les spécificateurs de mode d’accès diffèrent
suivant le type du fichier
Pour les fichiers TEXTES :
« r » lecture seule
« w » écriture seule (destruction de l'ancienne version si elle existe)
« w+ »lecture/écriture (destruction ancienne version si elle existe)
« r+ »lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version.
« a+ »lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version, le pointeur
est positionné à la fin du fichier.
Pour les fichiers BINAIRES :
« rb » lecture seule
« wb » écriture seule (destruction de l'ancienne version si elle existe)
« wb+ »lecture/écriture (destruction ancienne version si elle existe)
« rb+ »lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version.
« ab+ »lecture/écriture d'un fichier existant (mise à jour), pas de création d'une nouvelle version, le pointeur
est positionné à la fin du fichier.
A l’ouverture, le pointeur est positionné au début du fichier (sauf « a+ » et « ab+ »)
Exemple : FILE *fichier ;
fichier = fopen(‘’ D :\toto.dat ‘’, ‘’ rb ‘’) ;
Chapitre 2 Les fichiers
Rq : si l’exécution de la fonction fopen ne se déroule pas normalement, par exemple le fichier n’existe pas,
la valeur retournée est le pointeur NULL. Il est donc recommandé de toujours tester si la valeur renvoyée est
égale à NULL afin de détecter les erreurs.
4.3. Fermer un fichier : permet de fermer le flot qui a été associé à un fichier par fopen, sa syntaxe est
fclose(flot);
fclose retourne 0 si la fermeture s’est bien passée, une valeur non null (EOF) en cas d’erreur.
Il faut toujours fermer un fichier à la fin d'une session.
Exemple :
FILE *fichier ;
fichier = fopen( ‘’ a :\toto.dat ’’ ,’’ rb ‘’) ;
/* Ici instructions de traitement */
fclose(fichier) ;
4.4. Détruire un fichier : remove( ‘’nom du fichier’’);
Exemple : remove(‘’ D :\toto.dat ‘’) ;
4.5. Renommer un fichier : rename(‘’ ancient nom ‘’, ‘’ nouveau nom ‘’);
4.6. Positionnement du pointeur au début du fichier : void rewind(FILE *fichier);
4.7. Opération de lecture et d’écriture :
Pour lire ou écrire des données dans un fichier, on dispose de fonctions analogues à celles qui servent à saisir
des données au clavier et à les afficher à l’écran. On peut utiliser la lecture et l’écriture par :
 Caractères,
 Par ligne,
 Avec formatage,
 Ou aussi transférer des blocs quelconques de données depuis ou vers un fichier.
La position à laquelle on lit ou on écrit dans un fichier est donner par un pointeur spécifique (seek pointer).
Après chaque lecture ou écriture, ce pointeur est déplacé de manière conforme.
4.7.1. Lecture / Ecriture des données en mode caractères :
Les fonctions fputc et fgetc permettent d’écrire ou de lire des caractères isolés dans un fichier.
a) Ecriture en mode caractère avec fputc
Voici son prototype : int fputc( int « caractère », FILE * « pointeur_fichier ») ;
Exemple : fputc(‘A’ , fp) ; écrit le caractère ‘A’ dans le fichier rattaché à fp (FILE *fp), à la position de
traitement courante.
b) Lecture en mode caractère avec fgetc
Son prototype est : int fgetc(FILE * « pointeur_fichier ») ;
Exemple :
int c ; /*tanpon caractère */
c=fgetc(fp) ; lit un caractère dans le fichier et le range dans la variable c.
La boucle : while((c=fgetc(fp) != EOF) /* Retourne EOF en cas d’erreur.*/
putchar(c);
Permet d’afficher le contenu tout entier du fichier.
Chapitre 2 Les fichiers
Rq : on peut remplacer fgetc et fputc par les macros getc et putc. Qui fonctionnent de la même façon.
4.7.2. Lecture / Ecriture des données en mode chaîne :
a) Lecture de chaîne de caractères avec fgets.
La fonction fgets lit da,s un fichier, à partir de la position courante, un certain nombre de caractères ( au plus
<nombre> - 1) et le range dans à l’emplacement mémoire référencé par <pointeur_tanpon>, cela jusqu’à ce
que se produise un des évènements suivants :
Le caractère de saut de ligne ‘’\n’’ a été lu : si fgets rencontre le caractère new-line ‘’\n’’, la fonction se
termine. La fonction gets remplace le caractère \n par \0.
<nombre> - 1 caractères ont déjà été lus : fgets lu au plus <nombre> - 1caractère dans le fichier concerné. La
raison en est que fgets, à la fin de l’opération de lecture, ajoute encore le caractère nul \0 à la chaîne lue, ce
qui donne en tout <nombre> caractères mémorisés.
La fin du fichier a été rencontrée.
Dans tous les cas, fgets termine la chaîne lue par le caractère \0.
Exemple :
FILE *fp ;
char stringbuf[81] ;
Après : fp = fopen(‘’ data.fil ‘’ , ‘’r’’);
L’instruction : fgets ( stringbuf , 81 , fp ); lirait au plus 80 caractères dans le fichier data.fil et les rangerait
dans stringbuf, accompagnés d’un caractère nul de fin de chaîne.
b) Ecriture de chaîne de caractères avec fputs.
La fonction d’affichage fputs écrit une chaîne de caractère dans un fichier à la position courante, le caractère
nul de fin de chaîne n’est pas recopié. Elle retourne une valeur non négative (par exemple 0 ou bien le code
ASCII du dernier caractère écrit) si l’écriture s’est déroulé sans encombre. La valeur de retour EOF indique
une erreur.
Son prototype : char *fputs(char *<pointeur_tanpon> , FILE *<pointeur_fichier>).
Exemple 1:
char strinbuf[] = ‘’ voici un exemple d’écriture. ‘’ ;
L’instruction : fputs ( strinbuf , fp ) ; écrit la chaine voici un exemple d’écriture. Dans le fichier référencé par
fp.
Exemple 2:
L’instruction fputs(’ voici un exemple d’écriture. ‘’ , stdout) ; ou fputs ( strinbuf , stdout) ; affiche la chaine
voici un exemple d’écriture. à l’écran
4.7.3. Lecture et Ecriture formatées :
Les fonctions fprintf et fscanf permettent d’effectuer des lectures ou des écritures formatées de données
dans un fichier. Les deux fonctions travaillent pratiquement comme les fonctions de terminal printf et scanf.
En particulier, elles emploient les mêmes formatages. La seule différence est que fprintf et fscanf réclament
un pointeur FILE en plus d’une chaîne de formatage et d’autres paramètres effectifs éventuels.
a) Lecture formatée dans un fichier : fscanf
Pour lire des données numériques (des nombres) ou autres dans un fichier, on peut utiliser la fonction fscanf,
qui est analogue à scanf sauf qu’elle lit dans un fichier au lieu de lire au clavier.
Chapitre 2 Les fichiers
La fonction fscanf prend pour premier paramètre le pointeur de fichier, puis les autres paramètres sont les
mêmes que ceux de scanf (la chaîne de format avec des %d,%f,..., puis les adresses des variables avec des &).
La fonction fscanf (et scanf) retourne le nombre de variables effectivement lues, qui peut être inférieur au
nombre de variables dont la lecture est demandée en cas d’erreur ou de fin de fichier. Ceci permet de
détecter la fin du fichier ou les erreurs de lecture dans in if ou dans un while.
Exemple
Chargement d’un fichier d’entiers en mémoire centrale. On suppose que dans un fichier texte sont écrits des
nombres entiers séparés par des espaces : 10 2 35 752 -5 4 -52 etc.
Nous allons charger ces entiers en mémoire centrale (c’est-à-dire les mettre dans un tableau), puis nous
allons afficher le tableau.
#include <stdio.h>
#include <stdlib.h> /* pour utiliser la fonction exit */
#define NB_ELEM_MAX 100
int ChargeFichier(int tableau[NB_ELEM_MAX])
{
FILE *fp;
int i=0;
/* ouverture du fichier : */
fp = fopen("monfichier.txt", "rt");
if (fp ==NULL) /* gestion d’erreur */
{
puts("Erreur d’ouverture de fichier :");
puts("Fichier inexistant ou permissions insuffisantes");
exit(1); /* termine le programme avec code d’erreur */
}
/* on peut mettre des appels de fonctions comme fscanf dans une condition. Ici, fscanf retourne 1 en cas
de succes */
while (i < NB_ELEM_MAX && fscanf(fp, "%d", &tableau[i])==1)
i++; /* incrementation : pareil que i=i+1 */
fclose(fp); /* fermeture du fichier */
return i; /* on retourne le nombre d’elements lus */
}
void Affiche(int tableau[], int n)
{
int i;
for (i=0 ; i<n ; i++)
printf("tableau[%d] = %d\n", i, tableau[i]);
}
int main()
{
int tab[NB_ELEM_MAX];
int n;
n = ChargeFichier(tab);
Affiche(tab, n);
return 0;
}

 La fonction exit de la bibliothèque stdlib.h permet de terminer le programme à l’endroit où elle est
appelée (avec éventuellement un code d’erreur passé en paramètre qui est transmis au système).
Chapitre 2 Les fichiers
 le return qui sort de la fonction en cours mais ne termine pas le programme (sauf si la fonction en
cours est le main).
 Notons qu’à chaque lecture par fscanf, le pointeur de fichier passe à la suite dans le fichier. Le
pointeur avance automatiquement dans le fichier lorsqu’on effectue une lecture, sans qu’il n’y ait
besoin d’incrémenter une variable.
 Notons la condition dans le while qui teste la valeur retournée par fscanf. Dans cet exemple, on
demande à lire une seule valeur dans le fscanf. La fonction fscanf doit retourner 1 en cas de succès.
À la fin du fichier, la lecture de la valeur échoue dans le fscanf, et la fonction fscanf retourne alors
une valeur différente de 1.
 Les instructions : fscanf(stdin , … ) ; et scanf( … ) ; sont équivalentes ( lecture par clavier ).
b) Écrire formatée dans un fichier : fprintf
Pour écrire dans un fichier, le fichier doit préalablement avoir été ouvert en mode "w", "a", "r+", "w+" ou
"a+".
Pour écrire des données numériques (des nombres) ou autre dans un fichier texte, on peut utiliser la fonction
fprintf, qui est analogue à la fonction printf. La fonction fprintf prend comme premier paramètre un pointeur
de fichier. Les autres paramètres sont les mêmes que pour printf ; le second paramètre est la chaîne de
format avec le texte à écrire et les %d,%f, puis suivent les variables à écrire séparées par des virgules.
 Les instructions : fprintf(stdout , … ) ; et printf( … ) ; sont équivalentes ( affichent sur écran ).

Exemple
Voici un programme qui lit un fichier texte contenant des nombres entiers, et écrit un fichier texte contenant
les entiers triples (chaque entier est multiplié par 3).

#include <stdio.h>
int TripleFichier(void)
{
FILE *fpr, *fpw; /* deux pointeurs pour deux fichiers */
int n; /* pour lire */
fpr = fopen("fichierLecture.txt", "rt");
fpw = fopen("fichierEcriture.txt", "wt");
if (fpr==NULL || fpw==NULL) /* gestion d’erreur */
return 1; /* code d’erreur retourne au main */
while (fscanf(fpr, "%d", &n)==1) /* lecture d’un entier */
fprintf(fpw, "%d ", 3*n); /* ecriture du triple */
fclose(fpr); /* fermeture des deux fichiers */
fclose(fpw);
return 0; /* pas d’erreur */
}
int main()
{
int codeErr;
codeErr = TripleFichier();
/* on recupere le code d’erreur dans le main : */
if(codeErr != 0)
puts("Erreur d’ouverture de fichier !");
return 0;
}
Chapitre 2 Les fichiers
4.7.4. Lecture et Ecriture par bloc
Les fonctions d’entrée-sortie présentées jusqu’ici sont adaptées au traitement d’entités de différents types,
qu’il s’agisse de lire ou d’écrire dans un fichier des caractères, des chaînes (par exemple des lignes) ou des
valeurs numériques. Mais, avec fread et fwrite, on dispose également de deux fonctions qui permettent de
transférer depuis ou vers un fichier, non pas des entités complètes, un nombre quelconque d’octets (cela
indépendamment de la nature des données transférées).
a) Lecture de bloc dans un fichier : fread
Pour lire dans un fichier binaire, on lit en général dans le fichier les éléments d’un tableau. Chaque élément
du tableau est appelé un bloc. Chaque bloc possède une taille en octets. Par exemple, un char correspond à
1 octet, un float correspond à 4 octets, etc.
La fonction sizeof donne la taille de chaque type. Par exemple, sizeof(char) vaut 1, et sizeof(float) vaut 4. On
utilisera de préférence la fonction sizeof plutôt qu’une constante comme 1 ou 4 car cela augmente la lisibilité
du programme et le programme ne dépend pas du compilateur ou du système. Par exemple la taille d’un int
peut être soit 2 soit 4, mais sizeof(int) est toujours correct.
La fonction de lecture fread prend en paramètre le tableau, la taille de chaque bloc, le nombre de blocs à lire
(nombre d’éléments du tableau), et le pointeur de fichiers. La taille physique du tableau doit être au moins
égale au nombre de blocs lus, pour éviter une erreur mémoire. La fonction fread transfère les données du
fichier binaire vers le tableau.
La fonction fread retourne le nombre d’éléments effectivement lus. Si ce nombre est inférieur au nombre
effectivement demandé, soit il s’est produit une erreur de lecture, soit la fin du fichier a été atteinte.
Exemple
Supposons qu’un fichier contienne le codage d’un tableau d’entiers que l’on va charger en mémoire centrale.
Le fichier contiendra un int et des float. Le premier élément du fichier (de type int) donne le nombre
d’éléments de type float qui se trouvent à la suite. Le programme suivant réalise le chargement d’un tableau
en mémoire et son affichage dans la console.
#include <stdio.h>
#include <stdlib.h>
/* le nom du fichier est passé en paramètre (type char*) */
float* Chargement(char* nomFichier, int *adrNbElem)
{
int n, ret;
float *tableau;
FILE *fp;
if ((fp=fopen(nomFichier, "r")) == NULL)
{
printf("Erreur :");
puts("fichier introuvable ou droits insuffisants");
exit(1);
}
fread(&n sizeof(int), 1, fp); /* on lit le nombre d’éléments */
*adrNbElem = n; /* passage par adresse */
/* le nombre d’éléments connu, on alloue le tableau : */
tableau = (float*)malloc(n*sizeof(float)); /* allocation */
ret = fread(tableau, sizeof(float), n, fp);
if (ret!=n) /* lecture des éléments */
puts("Erreur de lecture ou fin de fichier !");
fclose(fp); /* fermeture du fichier (obligatoire) */
return tableau;
Chapitre 2 Les fichiers

}
void Affichage(float* tableau, int nb)
{
int i;
for (i=0 ; i<nb ; i++)
printf("%.3f ", tableau[i]);
}
int main(void)
{
int nb; /* nb n’est pas un pointeur mais un int */
float *tableau;
tableau = Chargement("monfichier.dat", &nb);
Affichage(tableau, nb);
free(tableau); /* libération de mémoire */
return 0;
}

b) Ecriture de bloc dans un fichier : fwrite

Pour écrire dans un fichier binaire, on utilise la fonction fwrite qui transfère des données de la mémoire
centrale vers un fichier binaire. Comme la fonction fread, la fonction fwrite prend en paramètre le tableau,
la taille de chaque bloc, le nombre de blocs à écrire et le pointeur de fichier. La taille physique du tableau
doit être au moins égale au nombre de blocs écrits, pour éviter une erreur mémoire. La fonction fwrite
transfère les données du tableau vers le fichier binaire.
La fonction fwrite retourne le nombre d’éléments effectivement écrits. Si ce nombre est inférieur au nombre
effectivement demandé, il s’est produit une erreur d’écriture (fichier non ouvert, disque plein...).
Exemple
Le programme suivant lit au clavier un tableau de nombres réels et les sauvegarde dans un fichier binaire. Le
format du fichier est le même que pour l’exemple précédent : on trouve d’abord le nombre d’éléments, puis
les éléments à la suite dans le fichier.
#include <stdio.h>
#include <stdlib.h>
float* LectureTableau(int* adrNbElem)
{
float *tableau;
int i;
puts("Entrez le nombre d’éléments");
scanf("%d", adrNbElem); /* passage par adresse, pas de & */
tableau = (float*)calloc(*adrNbElem, sizeof(float));
for (i=0 ; i<*adrNbElem ; i++)
scanf("%f", &tableau[i]);
return tableau;
}
void Sauvegarde(int *tableau, int nb, char* nomFichier)
{
FLIE *fp;
if ((fp=fopen(nomFichier, "w")) == NULL)
{
puts("Permission refusée ou répertoire inexistant");
Chapitre 2 Les fichiers
exit(1);
}
/* écriture du nombre d’éléments */
fwrite(&nb, sizeof(int), 1, fp)
/* écriture des éléments */
if (fwrite(tableau, sizeof(float), nb, fp)!=nb)
puts("Erreur d’écriture dans le fichier !");
fclose(fp);
}
int main(void)
{
int nb; /* ne pas mettre un pointeur ici */
float* tableau;
tableau = LectureTableau(&nb);
Sauvegarde(tableau, nb, "monfichier.dat")
free(tableau); /* libération de mémoire */
return 0;
}

4.8. Se positionner dans un fichier binaire

À chaque instant, un pointeur de fichier ouvert se trouve à une position courante, c’est-à-dire que le pointeur
de fichier est prêt pour lire ou écrire à un certain emplacement dans le fichier. Chaque appel à fread ou fwrite
fait avancer la position courante du nombre d’octets lus ou écrits.
La fonction fseek permet de se positionner dans un fichier, en modifiant la position courante pour pouvoir
lire ou écrire à l’endroit souhaité. Lorsqu’on écrit sur un emplacement, la donnée qui existait éventuellement
à cet emplacement est effacée et les fichiers permettent de stocker ou de lire des données sur un support
permanent tel que le disque dur. Les données sont mémorisées sous la forme d'une suite d'octets.
Résumé : Pour utiliser un fichier, on peut choisir entre deux modes d'accès : binaire ou texte.
– fichier rempli en mode binaire : chaque information est stockée selon les règles de codage imposées par
son type. Les données ne peuvent être lues/écrites que par programme. La taille du fichier est alors optimale
et les données sont facilement lues/écrites en peu d’instructions. Mais on ne peut pas éditer le fichier pour
en vérifier ou en modifier le contenu.
Application : c'est le fichier le plus simple à utiliser pour faire des sauvegardes de données entre deux appels
d'un programme. Il se prête aussi très bien à la gestion de bases de données.
Pour lire/écrire dans un fichier binaire, il existe deux fonctions rapides à utiliser (fread, fwrite). On peut aussi
se positionner n'importe où dans le fichier (fseek).
– fichier rempli en mode texte : chaque information est stockée sous la forme d’une succession de codes
ASCII. Les données du fichier peuvent être créées ou consultées par l'utilisateur à l'aide d'un éditeur de texte,
en plus de leur accès par programme. En contrepartie, elles occupent souvent plus de place et sont plus
difficiles à manipuler par programme.
Un fichier texte est un cas particulier de fichier binaire : on peut donc le manipuler en accès binaire, avec les
fonctions de lecture/écriture binaires (fread, fwrite). Mais on utilise surtout des fonctions d’entrée/sortie
dites "formatées" (fprintf, fgets, fscanf,...), qui ressemblent à celles dont on dispose pour écrire à l'écran ou
lire au clavier.
Application : le fichier texte est plus long et plus délicat à lire/écrire que le fichier binaire "pur". Mais il
présente l'avantage d'être consultable (et modifiable) avec n'importe quel éditeur de texte, ce qui donne
Chapitre 2 Les fichiers
plus de marge de manoeuvre à l'utilisateur. C'est le fichier à employer quand l'utilisateur veut voir et
manipuler les données du fichier avec un éditeur de texte.
Quel que soit le type d'accès envisagé, binaire ou texte, il faut suivre la même procédure :
– ouvrir le fichier (fonction fopen) ; on indique le nom du fichier et les détails de l'accès envisagé.
– lire ou écrire dans le fichier : on utilise les fonctions autorisées par l'accès choisi (binaire ou texte).
– fermer le fichier (fonction fclose).