• 10 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 22/08/2022

Manipulez des fichiers à l'aide de fonctions

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Les variables n'existent que dans la mémoire vive : une fois votre programme arrêté, elles sont supprimées de la mémoire et il n'est pas possible de retrouver ensuite leur valeur. Comment peut-on faire un éditeur de texte si tout le texte écrit disparaît lorsqu'on arrête le programme ?

Pour lire et écrire dans des fichiers, nous allons nous servir de fonctions situées dans des bibliothèques standard.

Incluez au moins les bibliothèques stdio.h et stdlib.h en haut de votre fichier .c  :

#include <stdlib.h>
#include <stdio.h>

Je vous recommande d'ailleurs de les inclure dans tous vos futurs programmes, quels qu'ils soient.

Pour commencer, voyons d'abord comment ouvrir et fermer un fichier. Nous verrons ensuite comment le modifier.

Ouvrez un fichier avec  fopen

Chaque fois que vous voulez ouvrir un fichier, que ce soit pour le lire ou pour y écrire, il faut :

  1. Appeler la fonction d'ouverture de fichier fopen qui renvoie un pointeur sur le fichier.

  2. Vérifier si l'ouverture a réussi (c'est-à-dire si le fichier existait) en testant la valeur du pointeur qu'on a reçu. Nous verrons comment faire dans un instant.

Dans le chapitre sur les chaînes, nous nous sommes servis des prototypes des fonctions comme d'un mode d'emploi. Voyons justement le prototype de la fonction fopen  :

FILE* fopen(const char* nomDuFichier, const char* modeOuverture);

Cette fonction attend deux paramètres :

  1. Le nom du fichier à ouvrir.

  2. Le mode d'ouverture du fichier, c'est-à-dire une indication qui mentionne ce que vous voulez faire : seulement écrire dans le fichier, seulement le lire, ou les deux à la fois.

Il faut absolument récupérer ce pointeur pour pouvoir ensuite lire et écrire dans le fichier.

Créons donc un pointeur de FILE  au début de notre fonction, par exemple la fonction main :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
return 0;
}

Le pointeur est initialisé à NULL dès le début.

Maintenant, nous allons appeler la fonction fopen et récupérer la valeur qu'elle renvoie dans le pointeur fichier  . Mais avant ça, il faut que je vous explique comment se servir du second paramètre, le paramètre modeOuverture  . En effet, il y a un code à envoyer qui indiquera à l'ordinateur si vous ouvrez le fichier en mode de lecture seule, d'écriture seule, ou des deux à la fois.

Voici les principaux modes d'ouverture possibles :

  • "r"  : lecture seule. Vous pourrez lire le contenu du fichier, mais pas y écrire. Le fichier doit avoir été créé au préalable.

  • "w"  : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire son contenu. Si le fichier n'existe pas, il sera créé.

  • "a"  : mode d'ajout. Vous écrirez dans le fichier, en partant de la fin du fichier. Vous ajouterez donc du texte à la fin du fichier. Si le fichier n'existe pas, il sera créé. Ce mode d'ajout peut être utile si vous voulez seulement ajouter des informations à la fin du fichier.

  • "a+"  : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la fin du fichier. Si le fichier n'existe pas, il sera créé.

  • "r+"  : lecture et écriture. Vous pourrez lire et écrire dans le fichier. Le fichier doit avoir été créé au préalable.

  • "w+"  : lecture et écriture, avec suppression du contenu au préalable. Le fichier est donc d'abord vidé de son contenu, vous pouvez y écrire, et le lire ensuite. Si le fichier n'existe pas, il sera créé.

Le code suivant ouvre le fichier test.txt en mode "r+"  (lecture et écriture) :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
fichier = fopen("test.txt", "r+");
return 0;
}

Le pointeur fichier devient alors un pointeur sur test.txt  .

Où doit être situé test.txt  ?

Il doit être situé dans le même dossier que votre exécutable ( .exe  ). Pour les besoins de ce chapitre, créez un fichier test.txt dans le même dossier que le .exe :

Créez un fichier texte à la racine du projet pour l’utiliser dans votre programme. Le fichier doit être placé dans le même dossier que l'exécutable. On voit dans cette capture d'écran la création du fichier test.txt dans le dossier.
Créez un fichier texte

Le fichier doit-il être de type .txt  ?

Non. C'est vous qui choisissez l'extension lorsque vous ouvrez le fichier. Vous pouvez très bien inventer votre propre format de fichier.

Le fichier doit-il être obligatoirement dans le même répertoire que l'exécutable ?

Non plus. Il peut être dans un sous-dossier :

fichier = fopen("dossier/test.txt", "r+");

Ici, le fichier test.txt est dans un sous-dossier appelé dossier  . Cette méthode, que l'on appelle "chemin relatif", est plus pratique. Comme ça, cela fonctionnera, peu importe l'endroit où est installé votre programme.

Il est aussi possible d'ouvrir un autre fichier n'importe où ailleurs sur le disque dur. Dans ce cas, il faut écrire le chemin complet (ce qu'on appelle le "chemin absolu") :

fichier = fopen("C:\\Program Files\\Notepad++\\readme.txt", "r+");

Ce code ouvre le fichier readme.txt situé dans C:\Program Files\Notepad++  .

Le défaut des chemins absolus, c'est qu'ils ne fonctionnent que sur un système d'exploitation précis. Ce n'est pas une solution portable, donc. Si vous aviez été sous Linux, vous auriez dû écrire un chemin "à la Linux", tel que :

fichier = fopen("/home/mateo/dossier/readme.txt", "r+");

Le pointeur fichier devrait contenir l'adresse de la structure de type FILE qui sert de descripteur de fichier. Celui-ci a été chargé en mémoire pour vous par la fonction fopen()  .

À partir de là, deux possibilités :

  1. Soit l'ouverture a réussi : vous pouvez commencer à lire et écrire dans le fichier via des fonctions que je vais vous présenter dans la suite de ce chapitre.

  2. Soit l'ouverture a échoué parce que le fichier n'existait pas ou était utilisé par un autre programme : vous devez arrêter de travailler sur le fichier.

On va donc suivre systématiquement le schéma suivant :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
fichier = fopen("test.txt", "r+");
if (fichier != NULL)
{
// On peut lire et écrire dans le fichier
}
else
{
// On affiche un message d'erreur si on veut
printf("Impossible d'ouvrir le fichier test.txt");
}
return 0;
}

Faites toujours cela lorsque vous ouvrez un fichier. Si vous ne le faites pas et que le fichier n'existe pas, vous risquez un plantage du programme par la suite.

Fermez un fichier avec fclose

Si l'ouverture du fichier a réussi, vous pouvez le lire et y écrire (nous allons voir sous peu comment faire).
Une fois que vous aurez fini de travailler avec le fichier, il faudra le « fermer ». On utilise pour cela la fonction fclose  qui a pour rôle de libérer la mémoire, c'est-à-dire supprimer votre fichier chargé dans la mémoire vive.

Son prototype est :

int fclose(FILE* pointeurSurFichier);

Cette fonction prend un paramètre : votre pointeur sur le fichier.
Elle renvoie un int  qui indique si elle a réussi à fermer le fichier. Ce int  vaut :

  • 0  : si la fermeture a marché ;

  • EOF  : si la fermeture a échoué. EOF  est un define  situé dans stdio.h  qui correspond à un nombre spécial, utilisé pour dire soit qu'il y a eu une erreur, soit que nous sommes arrivés à la fin du fichier. Dans le cas présent, cela signifie qu'il y a eu une erreur.

À priori, la fermeture se passe toujours bien : je n'ai donc pas l'habitude de tester si le fclose  a marché. Vous pouvez néanmoins le faire si vous le voulez.

Pour fermer le fichier, on va donc écrire :

fclose(fichier);

Au final, le schéma que nous allons suivre pour ouvrir et fermer un fichier sera le suivant :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
fichier = fopen("test.txt", "r+");
if (fichier != NULL)
{
// On lit et on écrit dans le fichier
// ...
fclose(fichier); // On ferme le fichier qui a été ouvert
}
return 0;
}

Je n'ai pas mis le else  ici pour afficher un message d'erreur si l'ouverture a échoué, mais vous pouvez le faire si vous le désirez.

Il faut toujours penser à fermer son fichier une fois que l'on a fini de travailler avec. Cela permet de libérer de la mémoire.
Si vous oubliez de libérer la mémoire, votre programme risque à la fin de prendre énormément de mémoire qu'il n'utilise plus. Sur un petit exemple comme ça ce n'est pas flagrant, mais sur un gros programme, bonjour les dégâts !

Oublier de libérer la mémoire, ça arrive. Ça vous arrivera d'ailleurs très certainement. Dans ce cas, vous serez témoin de ce que l'on appelle des fuites mémoire. Votre programme se mettra alors à utiliser plus de mémoire que nécessaire sans que vous arriviez à comprendre pourquoi. Bien souvent, il s'agit simplement d'un ou deux « détails », comme des petits fclose  oubliés.

Maintenant que nous avons écrit le code qui ouvre et ferme le fichier, nous n'avons plus qu'à insérer le code qui le lit et y écrit.

Nous allons commencer par voir comment écrire dans un fichier (ce qui est un peu plus simple), puis nous verrons ensuite comment lire dans un fichier.

Écrivez dans un fichier

Il existe plusieurs fonctions capables d'écrire dans un fichier. Ce sera à vous de choisir celle qui est la plus adaptée à votre cas.
Voici les trois fonctions que nous allons étudier :

  1. fputc écrit un caractère dans le fichier (UN SEUL caractère à la fois).

  2. fputs écrit une chaîne dans le fichier.

  3. fprintf écrit une chaîne formatée dans le fichier.

1. Écrivez un caractère dans le fichier avec fputc

Cette fonction écrit un caractère à la fois dans le fichier. Son prototype est :

int fputc(int caractere, FILE* pointeurSurFichier);

Elle prend deux paramètres.

  • Le caractère à écrire (de type int  , ce qui comme je vous l'ai dit revient plus ou moins à utiliser un char  , sauf que le nombre de caractères utilisables est ici plus grand). Vous pouvez donc écrire directement 'A'  , par exemple.

  • Le pointeur sur le fichier dans lequel écrire. Dans notre exemple, notre pointeur s'appelle fichier  . L'avantage de demander le pointeur de fichier à chaque fois, c'est que vous pouvez ouvrir plusieurs fichiers en même temps, et donc lire et écrire dans chacun de ces fichiers. Vous n'êtes pas limité à un seul fichier ouvert à la fois.

La fonction retourne un int  , c'est un code d'erreur. Ce int vaut EOF si l'écriture a échoué, sinon il a une autre valeur.
Comme le fichier a normalement été ouvert avec succès, je n'ai pas l'habitude de tester si chacun de mes fputc a réussi, mais vous pouvez le faire encore une fois si vous le voulez.

Le code suivant écrit la lettre 'A' dans test.txt  (si le fichier existe, il est remplacé ; s'il n'existe pas, il est créé). Il y a tout dans ce code : ouverture, test de l'ouverture, écriture et fermeture.

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
fichier = fopen("test.txt", "w");
if (fichier != NULL)
{
fputc('A', fichier); // Écriture du caractère A
fclose(fichier);
}
return 0;
}

Ouvrez votre fichier test.txt  .   Que voyez-vous ?
C'est magique, le fichier contient maintenant la lettre 'A' : 

La fonction fputc permet d’écrire un caractère dans un fichier.. Le fichier contient désormais la lettre 'A'
Écrire un caractère dans un fichier
2. Écrivez une chaîne dans le fichier avec fputs

Cette fonction est très similaire à fputc  , à la différence près qu'elle écrit tout une chaîne, ce qui est en général plus pratique que d'écrire caractère par caractère.
Cela dit, fputc reste utile lorsque vous devez écrire caractère par caractère, ce qui arrive fréquemment.

Prototype de la fonction :

char* fputs(const char* chaine, FILE* pointeurSurFichier);

Les deux paramètres sont faciles à comprendre.

  • chaine  : la chaîne à écrire. Notez que le type ici est const char*  : en ajoutant le motconst dans le prototype, la fonction indique que pour elle la chaîne sera considérée comme une constante. En un mot comme en cent : elle s'interdit de modifier le contenu de votre chaîne. C'est logique quand on y pense : fputs doit juste lire votre chaîne, pas la modifier. C'est donc pour vous une information (et une sécurité) indiquant que votre chaîne ne subira pas de modification.

  • pointeurSurFichier  : comme pour fputc  , il s'agit de votre pointeur de type FILE* sur le fichier que vous avez ouvert.

La fonction renvoie EOF s'il y a eu une erreur, sinon c'est que cela a fonctionné. Là non plus, je ne teste en général pas la valeur de retour.

Testons l'écriture d'une chaîne dans le fichier :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
fichier = fopen("test.txt", "w");
if (fichier != NULL)
{
fputs("Salut les développeurs\nBienvenue sur OpenClassrooms !", fichier);
fclose(fichier);
}
return 0;
}

Voici le fichier une fois modifié par le programme :

La fonction fputs permet d’écrire une chaîne de caractère dans un fichier.  On voit le fichier .txt qui affiche le message
Écrire une chaîne de caractères dans un fichier
3. Écrivez une chaîne "formatée" dans le fichier avec fprintf

Voici un autre exemplaire de la fonction printf  . Celle-ci peut être utilisée pour écrire dans un fichier. Elle s'utilise de la même manière que printf  d'ailleurs, excepté le fait que vous devez indiquer un pointeur de FILE  en premier paramètre.

Ce code demande l'âge de l'utilisateur et l'écrit dans le fichier (résultat fig. suivante) :

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
int age = 0;
fichier = fopen("test.txt", "w");
if (fichier != NULL)
{
// On demande l'âge
printf("Quel age avez-vous ? ");
scanf("%d", &age);
// On l'écrit dans le fichier
fprintf(fichier, "Le Monsieur qui utilise le programme, il a %d ans", age);
fclose(fichier);
}
return 0;
}
La fonction fprintf permet d’écrire une chaîne de caractère dans un fichier.
Écrire une chaîne de caractères avec fprintf

Vous pouvez ainsi facilement réutiliser ce que vous savez de printf  pour écrire dans un fichier ! C'est pour cette raison d'ailleurs que j'utilise le plus souvent fprintf  pour écrire dans des fichiers.

Lisez dans un fichier

Nous pouvons utiliser quasiment les mêmes fonctions que pour l'écriture, le nom change juste un petit peu :

  1. fgetc lit un caractère.

  2. fgets lit une chaîne.

  3. fscanf lit une chaîne "formatée".

Je vais cette fois aller un peu plus vite dans l'explication de ces fonctions : si vous avez compris ce que j'ai écrit plus haut, ça ne devrait pas poser de problème.

1. Lisez un caractère avec fgetc

Tout d'abord le prototype :

int fgetc(FILE* pointeurDeFichier);

Cette fonction retourne un int  : c'est le caractère qui a été lu.
Si la fonction n'a pas pu lire de caractère, elle retourne EOF  .

Mais comment savoir quel caractère on lit ? Si on veut lire le troisième caractère, ainsi que le dixième caractère, comment doit-on faire ?

En fait, au fur et à mesure que vous lisez un fichier, vous avez un « curseur » qui avance. C'est un curseur virtuel bien entendu, vous ne le voyez pas à l'écran. Vous pouvez imaginer que ce curseur est comme la barre clignotante lorsque vous éditez un fichier sous Bloc-Notes. Il indique où vous en êtes dans la lecture du fichier.

Nous verrons peu après comment savoir à quelle position le curseur est situé dans le fichier, et également comment modifier la position du curseur (pour le remettre au début du fichier par exemple, ou le placer à un caractère précis, comme le dixième caractère).

fgetc  avance le curseur d'un caractère à chaque fois que vous en lisez un. Si vous appelez fgetc  une seconde fois, la fonction lira donc le second caractère, puis le troisième et ainsi de suite. Vous pouvez donc faire une boucle pour lire les caractères un par un dans le fichier.

On va écrire un code qui lit tous les caractères d'un fichier un à un, et qui les écrit à chaque fois à l'écran. La boucle s'arrête quand fgetc  renvoie EOF  (qui signifie « End Of File », c'est-à-dire « fin du fichier »).

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
int caractereActuel = 0;
fichier = fopen("test.txt", "r");
if (fichier != NULL)
{
// Boucle de lecture des caractères un à un
do
{
caractereActuel = fgetc(fichier); // On lit le caractère
printf("%c", caractereActuel); // On l'affiche
} while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
fclose(fichier);
}
return 0;
}

La console affichera tout le contenu du fichier, par exemple :

Coucou, je suis le contenu du fichier test.txt !

2. Lisez une chaîne avec fgets

Cette fonction lit une chaîne dans le fichier. Ça vous évite d'avoir à lire tous les caractères un par un. La fonction lit au maximum une ligne (elle s'arrête au premier \n  qu'elle rencontre). Si vous voulez lire plusieurs lignes, il faudra faire une boucle.

Voici le prototype de fgets  :

char* fgets(char* chaine, int nbreDeCaracteresALire, FILE* pointeurSurFichier);

Cette fonction demande un paramètre un peu particulier, qui va en fait s'avérer très pratique : le nombre de caractères à lire. Cela demande à la fonction fgets  de s'arrêter de lire la ligne si elle contient plus de X caractères.
Avantage : ça nous permet de nous assurer que l'on ne fera pas de dépassement de mémoire ! En effet, si la ligne est trop grosse pour rentrer dans chaine  , la fonction aurait lu plus de caractères qu'il n'y a de place, ce qui aurait probablement provoqué un plantage du programme.

Nous allons d'abord voir comment lire une ligne avec fgets  (nous verrons ensuite comment lire tout le fichier).

Pour cela, on crée une chaîne suffisamment grande pour stocker le contenu de la ligne qu'on va lire (du moins on l'espère, car on ne peut pas en être sûr à 100 %). Vous allez voir là tout l'intérêt d'utiliser un define  pour définir la taille du tableau :

#define TAILLE_MAX 1000 // Tableau de taille 1000
int main(int argc, char *argv[])
{
FILE* fichier = NULL;
char chaine[TAILLE_MAX] = ""; // Chaîne vide de taille TAILLE_MAX
fichier = fopen("test.txt", "r");
if (fichier != NULL)
{
fgets(chaine, TAILLE_MAX, fichier); // On lit maximum TAILLE_MAX caractères du fichier, on stocke le tout dans "chaine"
printf("%s", chaine); // On affiche la chaîne
fclose(fichier);
}
return 0;
}

Le résultat est le même que pour le code de tout à l'heure, à savoir que le contenu s'écrit dans la console :

Coucou, je suis le contenu du fichier test.txt !

La différence, c'est qu'ici on ne fait pas de boucle. On affiche toute la chaîne d'un coup.

Vous aurez sûrement remarqué maintenant l'intérêt que peut avoir un #define  dans son code pour définir la taille maximale d'un tableau, par exemple. En effet, TAILLE_MAX  est ici utilisé à deux endroits du code :

  • une première fois pour définir la taille du tableau à créer ;

  • une autre fois dans le fgets  pour limiter le nombre de caractères à lire.

L'avantage ici, c'est que si vous vous rendez compte que la chaîne n'est pas assez grande pour lire le fichier, vous n'avez qu'à changer la ligne du define  et recompiler. Cela vous évite d'avoir à chercher tous les endroits du code qui indiquent la taille du tableau. Le préprocesseur remplacera tous les TAILLE_MAX  dans le code par leur nouvelle valeur.

Comme je vous l'ai dit, fgets  lit au maximum toute une ligne à la fois. Elle s'arrête de lire la ligne si elle dépasse le nombre maximum de caractères que vous autorisez.

Oui mais voilà : pour le moment, on ne sait lire qu'une seule ligne à la fois avec fgets  . Comment diable lire tout le fichier ? La réponse est simple : avec une boucle !

La fonction fgets  renvoie NULL  si elle n'est pas parvenue à lire ce que vous avez demandé.
La boucle doit donc s'arrêter dès que fgets  se met à renvoyer NULL  .

On n'a plus qu'à faire un while  pour boucler tant que fgets  ne renvoie pas NULL  :

#define TAILLE_MAX 1000
int main(int argc, char *argv[])
{
FILE* fichier = NULL;
char chaine[TAILLE_MAX] = "";
fichier = fopen("test.txt", "r");
if (fichier != NULL)
{
while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
{
printf("%s", chaine); // On affiche la chaîne qu'on vient de lire
}
fclose(fichier);
}
return 0;
}

Ce code source lit et affiche tout le contenu de mon fichier, ligne par ligne.

La ligne de code la plus intéressante est celle du while  :

while (fgets(chaine, TAILLE_MAX, fichier) != NULL)

La ligne du while  fait deux choses : elle lit une ligne dans le fichier et vérifie si fgets  ne renvoie pas NULL  . Elle peut donc se traduire comme ceci : « Lire une ligne du fichier tant que nous ne sommes pas arrivés à la fin du fichier ».

3. Lisez une chaîne "formatée" avec fscanf

C'est le même principe que la fonction scanf  , là encore.
Cette fonction lit dans un fichier qui doit avoir été écrit d'une manière précise.

Supposons que votre fichier contienne trois nombres séparés par un espace, qui sont par exemple les trois plus hauts scores obtenus à votre jeu :   15 20 30  .

Vous voudriez récupérer chacun de ces nombres dans une variable de type int  .
La fonction fscanf  va vous permettre de faire ça rapidement.

int main(int argc, char *argv[])
{
FILE* fichier = NULL;
int score[3] = {0}; // Tableau des 3 meilleurs scores
fichier = fopen("test.txt", "r");
if (fichier != NULL)
{
fscanf(fichier, "%d %d %d", &score[0], &score[1], &score[2]);
printf("Les meilleurs scores sont : %d, %d et %d", score[0], score[1], score[2]);
fclose(fichier);
}
return 0;
}
Les meilleurs scores sont : 15, 20 et 30

Comme vous le voyez, la fonction fscanf  attend trois nombres séparés par un espace ( "%d %d %d"  ). Elle les stocke ici dans notre tableau de trois blocs.

On affiche ensuite chacun des nombres récupérés.

Déplacez-vous dans un fichier

Je vous ai parlé d'une espèce de « curseur » virtuel tout à l'heure. Nous allons l'étudier maintenant plus en détail.

Chaque fois que vous ouvrez un fichier, il existe en effet un curseur qui indique votre position dans le fichier. Vous pouvez imaginer que c'est exactement comme le curseur de votre éditeur de texte (tel Bloc-Notes). Il indique où vous êtes dans le fichier, et donc où vous allez écrire.

En résumé, le système de curseur vous permet d'aller lire et écrire à une position précise dans le fichier.

Il existe trois fonctions à connaître :

  1. ftell indique à quelle position vous êtes actuellement dans le fichier.

  2. fseek positionne le curseur à un endroit précis.

  3. rewind remet le curseur au début du fichier (c'est équivalent à demander à la fonction fseek de positionner le curseur au début).

1. Situez-vous dans un fichier avec ftell

Cette fonction est très simple à utiliser. Elle renvoie la position actuelle du curseur sous la forme d'un long  :

long ftell(FILE* pointeurSurFichier);

Le nombre renvoyé indique donc la position du curseur dans le fichier.

2. Positionnez le curseur dans un fichier avec fseek

Le prototype de fseek  est le suivant :

int fseek(FILE* pointeurSurFichier, long deplacement, int origine);

La fonction fseek  permet de déplacer le curseur d'un certain nombre de caractères (indiqué par deplacement  ) à partir de la position indiquée par origine  .

  • Le nombre deplacement  peut être un nombre positif (pour se déplacer en avant), nul (= 0) ou négatif (pour se déplacer en arrière).

  • Quant au nombre origine  , vous pouvez mettre comme valeur l'une des trois constantes (généralement des define  ) listées ci-dessous :

    • SEEK_SET  : indique le début du fichier ;

    • SEEK_CUR  : indique la position actuelle du curseur ;

    • SEEK_END  : indique la fin du fichier.

Voici quelques exemples pour bien comprendre comment on jongle avec deplacement  et origine  .

  • Le code suivant place le curseur deux caractères après le début :

fseek(fichier, 2, SEEK_SET);
  • Le code suivant place le curseur quatre caractères avant la position courante :

fseek(fichier, -4, SEEK_CUR);

Remarquez que deplacement  est négatif car on se déplace en arrière.

  • Le code suivant place le curseur à la fin du fichier :

fseek(fichier, 0, SEEK_END);

Si vous écrivez après avoir fait un fseek  qui mène à la fin du fichier, cela ajoutera vos informations à la suite dans le fichier (le fichier sera complété).
En revanche, si vous placez le curseur au début et que vous écrivez, cela écrasera le texte qui se trouvait là. Il n'y a pas de moyen d'« insérer » de texte dans le fichier, à moins de coder soi-même une fonction qui lit les caractères d'après pour s'en souvenir avant de les écraser !

Mais comment puis-je savoir à quelle position je dois aller lire et écrire dans le fichier ?

C'est à vous de le gérer. Si c'est un fichier que vous avez vous-même écrit, vous savez comment il est construit. Vous savez donc où aller chercher vos informations : par exemple les meilleurs scores sont en position 0, les noms des derniers joueurs sont en position 50, etc.

Nous travaillerons sur un TP un peu plus tard dans lequel vous comprendrez, si ce n'est pas déjà le cas, comment on fait pour aller chercher l'information qui nous intéresse. N'oubliez pas que c'est vous qui définissez comment votre fichier est construit. C'est donc à vous de dire : « Je place le score du meilleur joueur sur la première ligne, celui du second meilleur joueur sur la seconde ligne, etc. »

3. Replacez le curseur au début du fichier avec rewind

Cette fonction est équivalente à utiliser fseek  pour nous renvoyer à la position 0 dans le fichier.

void rewind(FILE* pointeurSurFichier);

Nous terminerons ce chapitre en douceur par l'étude de deux fonctions très simples :

  • rename renomme un fichier ;

  • remove  supprime un fichier.

La particularité de ces fonctions est qu'elles ne nécessitent pas de pointeur de fichier pour fonctionner. Il suffira simplement d'indiquer le nom du fichier à renommer ou supprimer.

Renommez un fichier avec rename

Voici le prototype de cette fonction :

int rename(const char* ancienNom, const char* nouveauNom);

La fonction renvoie 0 si elle a réussi à renommer, sinon elle renvoie une valeur différente de 0 :

int main(int argc, char *argv[])
{
rename("test.txt", "test_renomme.txt");
return 0;
}

Supprimez un fichier avec remove

Cette fonction supprime un fichier sans demander son reste :

int remove(const char* fichierASupprimer);

Cette fonction tombe à pic pour la fin du chapitre, je n'ai justement plus besoin du fichier test.txt  , je peux donc me permettre de le supprimer :

int main(int argc, char *argv[])
{
remove("test.txt");
return 0;
}

En résumé

  • La bibliothèque standard fournit des fonctions pour pouvoir manipuler les fichiers ; cependant, il ne faut pas oublier d’inclure les bibliothèques stdio.h et stdlib.h .

  • La fonction fopen permet d’ouvrir un fichier. Il faut préciser en paramètre le chemin vers le fichier, et indiquer le mode d'ouverture pour travailler sur le fichier selon votre besoin.

  • Les fonctions fputc ,  fputs et fprintf permettent d’écrire dans un fichier.

  • Pour lire dans un fichier, il faut utiliser les fonctions fgetc ,  fgets et  fscanf .

  • Toujours fermer le fichier à l’aide de la fonction fclose après avoir terminé les manipulations sur celui-ci.

Je ne sais pas si vous vous souvenez, mais dans le chapitre des tableaux, je vous ai vaguement parlé d’allocation dynamique. Surprise ! Il est maintenant temps de découvrir cette notion. Rendez-vous au prochain chapitre...

Exemple de certificat de réussite
Exemple de certificat de réussite