Comme pour tout système d'exploitation, la gestion des fichiers est un concept central de Linux. Tout programmeur système l'apprendrait comme l'une de ses tâches de programmation initiales. Cet aspect de la programmation implique des fichiers système.
Grâce à la gestion des fichiers, on peut effectuer des opérations telles que créer, modifier, supprimer, etc. sur les fichiers système. Ici, dans cet article, j'essaie d'apporter les bases de la gestion des fichiers. J'espère que cet article effacera la couche supérieure de cet aspect multicouche.
Fonctions de gestion de fichiers
Dans cet article, nous aborderons les fonctions suivantes couramment utilisées dans la gestion des fichiers :
fopen()
FILE *fopen(const char *path, const char *mode);
La fonction fopen() permet d'ouvrir un fichier et d'y associer un flux d'E/S. Cette fonction prend deux arguments. Le premier argument est un pointeur vers une chaîne contenant le nom du fichier à ouvrir tandis que le second argument est le mode dans lequel le fichier doit être ouvert. Le mode peut être :
- ‘r’ : Ouvre le fichier texte pour le lire. Le flux est positionné au début du fichier.
- ‘r+’ : Ouvert pour la lecture et l'écriture. Le flux est positionné au début du fichier.
- ‘w’ : Tronque le fichier à zéro ou crée un fichier texte pour l'écriture. Le flux est positionné au début du fichier.
- ‘w+’ :Ouvert pour la lecture et l'écriture. Le fichier est créé s'il n'existe pas, sinon il est tronqué. Le flux est positionné au début du fichier.
- ‘a’ :Ouvrir pour l'ajout (écriture à la fin du fichier). Le fichier est créé s'il n'existe pas. Le flux est positionné à la fin du fichier.
- ‘a+’ :ouvert en lecture et en ajout (écriture en fin de fichier). Le fichier est créé s'il n'existe pas. La position initiale du fichier pour la lecture est au début du fichier, mais la sortie est toujours ajoutée à la fin du fichier.
La fonction fopen() renvoie un pointeur de flux FILE en cas de succès alors qu'elle renvoie NULL en cas d'échec.
fread() et fwrite()
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
Les fonctions fread/fwrite sont utilisées pour lire/écrire des données depuis/vers le fichier ouvert par la fonction fopen. Ces fonctions acceptent trois arguments. Le premier argument est un pointeur vers le tampon utilisé pour lire/écrire les données. Les données lues/écrites se présentent sous la forme d'éléments "nmemb" de chaque "taille" octets de long.
En cas de succès, fread/fwrite renvoie le nombre d'octets réellement lus/écrits depuis/vers le flux ouvert par la fonction fopen. En cas d'échec, un nombre moindre de byes (puis demandés en lecture/écriture) est retourné.
fseek()
int fseek(FILE *stream, long offset, int whence);
La fonction fseek() est utilisée pour définir l'indicateur de position de fichier pour le flux à une nouvelle position. Cette fonction accepte trois arguments. Le premier argument est le pointeur de flux FILE renvoyé par la fonction fopen(). Le deuxième argument "offset" indique le nombre d'octets à rechercher. Le troisième argument "d'où" indique d'où la recherche du nombre d'octets "offset" doit être effectuée. Les valeurs disponibles pour l'origine sont SEEK_SET, SEEK_CUR ou SEEK_END. Ces trois valeurs (dans l'ordre) représentent le début du fichier, la position actuelle et la fin du fichier.
En cas de succès, cette fonction renvoie 0, sinon elle renvoie -1.
fclose()
int fclose(FILE *fp);
La fonction fclose() vide d'abord le flux ouvert par fopen() puis ferme le descripteur sous-jacent. En cas de réussite, cette fonction renvoie 0, sinon la fin du fichier (eof) est renvoyée. En cas d'échec, si le flux est accédé plus loin, le comportement reste indéfini.
Le code
#include<stdio.h>
#include<string.h>
#define SIZE 1
#define NUMELEM 5
int main(void)
{
FILE* fd = NULL;
char buff[100];
memset(buff,0,sizeof(buff));
fd = fopen("test.txt","rw+");
if(NULL == fd)
{
printf("\n fopen() Error!!!\n");
return 1;
}
printf("\n File opened successfully through fopen()\n");
if(SIZE*NUMELEM != fread(buff,SIZE,NUMELEM,fd))
{
printf("\n fread() failed\n");
return 1;
}
printf("\n Some bytes successfully read through fread()\n");
printf("\n The bytes read are [%s]\n",buff);
if(0 != fseek(fd,11,SEEK_CUR))
{
printf("\n fseek() failed\n");
return 1;
}
printf("\n fseek() successful\n");
if(SIZE*NUMELEM != fwrite(buff,SIZE,strlen(buff),fd))
{
printf("\n fwrite() failed\n");
return 1;
}
printf("\n fwrite() successful, data written to text file\n");
fclose(fd);
printf("\n File stream closed through fclose()\n");
return 0;
} Le code ci-dessus suppose que vous avez un fichier de test "test.txt" placé au même emplacement à partir duquel cet exécutable sera exécuté.
Initialement le contenu du fichier est :
$ cat test.txt hello everybody
Maintenant, exécutez le code :
$ ./fileHandling File opened successfully through fopen() Some bytes successfully read through fread() The bytes read are [hello] fseek() successful fwrite() successful, data written to text file File stream closed through fclose()
Vérifiez à nouveau le contenu du fichier test.txt. Comme vous le voyez ci-dessous, le contenu du fichier a été modifié.
$ cat test.txt hello everybody hello