Nous allons voire dans ce tutoriel la solution la plus simple pour manipuler des fichiers en C.
Les includes :
Il faut utiliser les includes suivant pour pouvoir travailler avec les fichiers :
#include <stdlib.h> #include <stdio.h>
Type :
La manipulation des fichiers ‘haut niveau’ avec le C se fait via le type « FILE ». Voici la déclaration d’une variable de type fichier :
FILE *f = NULL;
Ouverture d’un fichier
L’ouverture d’un fichier se fait via la fonction suivante :
FILE *fopen ( const char * filename, const char * mode );
Le premier paramètre est le chemin du fichier et le second est le mode d’ouverture que l’on souhaite utiliser (écriture, lecture …).
Voici une liste non exhaustive des modes d’ouverture :
- ‘r’ : Lecture seule. Le fichier doit déjà exister
- ‘w’ : Ecriture seule. Si le fichier n’existe pas il est créé.
- ‘a’ : Ajout. Vous commencé à écrire à la fin du fichier. Si le fichier n’existe pas il est créé.
- ‘r+’ : Lecture et écriture. Le fichier doit déjà exister
- ‘w+’ : Lecture et écriture avec suppression du contenu à l’ouverture. Si le fichier n’existe pas il est créé.
- ‘a+’ : Ajout en lecture/écriture à partir de la fin du fichier. Si le fichier n’existe pas il est créé.
Tous ces modes permettent d’ouvrir des fichiers textes. Pour ouvrir en mode binaire il suffit de rajouter ‘b’ (‘rb’, ‘rb+’ …).
La fonction fopen renvoie un pointeur du type FILE si l’ouverture c’est correctement déroulé, ou alors un pointeur NULL. Voici un exemple d’utilisation :
int main() { FILE *f = NULL; // Ouverture en mode lecture seule f = fopen("mon_fichier.txt", "r"); if ( f == NULL) { printf ( "Ouverture du fichier échoué!"); } else { printf ( "Ouverture du fichier réussis !"); } return 0; }
Fermeture du fichier :
Il faut TOUJOURS fermer un fichier que l’on a ouvert. On utilise la fonction suivante :
int fclose ( FILE * stream );
On reprend l’exemple précédent :
int main() { FILE *f = NULL; // Ouverture en mode lecture seule f = fopen("mon_fichier.txt", "r"); if ( f == NULL) { printf ( "Ouverture du fichier échoué!"); // Ici pas besoin de fermer car le fichier n'a pas // été ouvert ! } else { printf ( "Ouverture du fichier réussis !"); fclose(f); // On ferme notre fichier } return 0; }
Lire dans un fichier :
Avant tout il faut expliquer comment on se balade dans le fichier. La manière la plus simple va être d’utiliser les fonctions de lecture fournit par la librairie standard. Ces fonctions utiliserons un « pointeur » qui leur permet de savoir ou elles se trouvent dans le fichier.
Il existe 3 fonctions différentes pour lire dans un fichier.
// Retourne 1 caractère int fgetc ( FILE * stream );
// Lit une ligne du fichier sur num caractère char * fgets ( char * str, int num, FILE * stream );
// Equivalent à scanf mais ur les fichiers int fscanf ( FILE * stream, const char * format, ... );
Voici des exemples pour fgetc et fgets. Ces deux exemples font la même chose, ils lisent l’ensemble du fichier et l’écrivent dans la console.
/** * Pour la fonction fgetc */ int main() { FILE* f = NULL; // La var c va contenir ce que revoie fgetc int c = 0; f = fopen("mon_fichier.txt", "r"); // Ci-dessous on utilise une subtilitée du C // En effet NULL = (void *)0 // Donc on peut remplacer if(f != NULL) par if(f) if (f) { c = fgetc(f); while (c != EOF) { printf("%c", c); c = fgetc(f); } fclose(f); } return 0; }
/** * Pour la fonction fgetcs */ // On défini une valeur maximale de caractère // à lire par ligne. Donc si une ligne fait 1050 caractères // les 26 derniers caractères ne seront pas lus #define LEN_LINE_MAX 1024 int main() { FILE* f = NULL; // Variable qui va contenir la ligne char str[LEN_LINE_MAX] = ""; f = f("mon_fichier.txt", "r"); if (f) { // fgets renvoie NULL quand elle arrive // en fin de fichier. Donc on utilise ici aussi // l'astuce précédente ou NULL = (void *)0 while (fgets(str, LEN_LINE_MAX, f)) { printf("%s", str); } fclose(f); } return 0; }
fscanf une manière un peut différente de travailler, il faut en effet que le fichier est une forme bien précise. Par exemple le fichier contient deux nombres de la manière suivante :
1502 3560
Voici le code qui permet de récupérer ces deux valeurs dans deux variables différentes avec fscanf :
int main() { FILE* f = NULL; // Les deux viriables dans lesquelles // on va sauver les valeurs int nombre_1; int nombre_2; f = fopen("mon_fichier.txt", "r"); if (f != NULL) { fscanf(f, "%d %d", &nombre_1, &nombre_2); printf("Les deux valeurs enregistrées dans le fichier sont : %d et %d", nombre_1, nombre_2); fclose(f); } return 0; }
Ecriture dans un fichier :
Pour écrire dans un fichier il y a trois fonctions importantes qui sont les équivalentes des fonctions que l’on a déjà vu pour la lecture.
// Ecrit un caractère dans le fichier int fputc ( int character, FILE * stream );
// Ecrit une chaîne de caractère dans le fichier. int fputs ( const char * str, FILE * stream );
// Equivalent à printf mais pour les fichiers int fprintf ( FILE * stream, const char * format, ... );
Voici trois exemples de code qui utilise ces fonctions. Dans leur fonctionnements elles sont entièrement similaires au fonction de lecture.
int main() { FILE* f = NULL; f = fopen("my_file.txt", "w"); if (f != NULL) { // On écrit le caractère 'x' fputc('x', f); fclose(f); } return 0; }
int main() { FILE* f = NULL; f = fopen("my_file.txt", "w"); if (f != NULL) { fputs("Coucou, ça code dure ?", f); fclose(f); } return 0; }
int main() { // valeur que l'on va sauver dans le fichier int age = 42; char *name = "Pascal"; FILE* f = NULL; f = fopen("my_file.txt", "w"); if (fichier != NULL) { // On l'écrit dans le fichier en utilisant // fprintf comme printf pour la console fprintf(f, "nom : %s \n age %d", name, age); fclose(f); } return 0; }
Se déplacer dans un fichier :
Il existe trois fonctions qui permettent de se déplacer dans un fichier.
long int ftell ( FILE * stream ); int fseek ( FILE * stream, long int offset, int origin ); void rewind ( FILE * stream );
La première ftell renvoie la position du pointeur dans le fichier (la position courante). La deuxième fseek permet de déplacer ce pointeur pour changer la position courante. Enfin la dernière rewind permet de placer le pointeur en début de fichier, cette fonction pouvant être remplacer par fseek avec les paramètres qui vont bien.
Voici divers exemples avec des commentaires pour mieux comprendre.
int main() { FILE* f = NULL; f = fopen("my_file.txt", "w"); if (fichier != NULL) { // SEEK_SET indique l'origine du fichier donc // cette ligne positionne le pointeur à la // cinquième positions du fichier fseek(f, 5, SEEK_SET); // SEEK_CUR indique la position du pointeur // cette ligne positionne le pointeur à la // cinquième positions après la position courante fseek(fichier, 5, SEEK_CUR); // SEEK_END indique la fin du fichier donc // cette ligne positionne le pointeur à // l'avant dernière position du fichier fseek(fichier, -1, SEEK_END); fclose(f); } return 0; }
Supprimer, Renommer, Copier/Coller …
Pour supprimer un fichier :
// Retourne 0 si correctement supprimé int remove ( const char * filename ); // exemple : int main() { return remove("my_file.txt"); }
Pour renommer :
// Retourne 0 si correctement renommé int rename ( const char * oldname, const char * newname ); // exemple : int main() { return int rename ( "my_file.txt", "my_new_name_file.txt"); }
Pour copier/coller :
Il n’ya pas de fonction pour copier/coller ou couper/coller un fichier, mais vous pouvez faire votre propre fonction ;).
J’essaierais d’étoffer ce document d’ici quelques semaines. Cependant ce document est un bon début lorsque l’on souhaite travailler avec les fichiers en C !