Fichiers

Tout est dans

#include <stdio.h> 

Lecture

Ouverture d'un fichier

FILE *file;
file = fopen("tilemap.txt", "r");

if (file == NULL)
    return -1; // ou exit(-1)

Lire le contenu

while (!feof(file))
{
    char line[MAXLINELENGTH] = "";
    fgets(line, MAXLINELENGTH, file);
    puts(line);
}

feof : ai-je atteint la fin du fichier

feof(file)

fget : lire un caractère

int character = fget(file);

• renvoie le caractère suivant lu dans le fichier
• ou alors EOF si on a atteint la fin du fichier

fgets : lire une ligne

fgets(line, MAXLINEENGTH, file)

fscanf : lire des données formatées

fscanf(file, "%s", &variable);

Remarque : scanf(...); c'est la même chose que fscanf(stdin, ...);.

Fermeture du fichier

A la fin, comme on est poli, on ferme le fichier :

fclose(file);

Ecriture

Ouverture du fichier pour y écrire

FILE *file;
file = fopen("tilemap.txt", "w");

if (file == NULL) {
    printf("Impossible d'ouvrir le fichier. Voici le code d'erreur : %d\n", errno);
    return -1; // ou exit(-1)
}   

Attention, le fichier sera complètement écrasé.

En cas d'erreur, file est le pointeur nul, et la variable errno contient un code erreur.

fprintf : écrire des données formatées

 fprintf( file, "x = %d\n", i );

Remarque : printf(...); c'est la même chose que fprintf(stdout, ...);. On peut aussi écrire dans la sortie d'erreur fprintf(stderr, ...);

Fermeture du fichier

A la fin, comme on est bien éduqué, on ferme le fichier :

fclose(file);

Autres fonctions

fflush : être sûr que le fichier est à jour

On vous a menti. Si tu dis d'écrire quelque chose, a priori le système ne l'écrit pas tout de suite sur le disque :

Voici ce qui se passe : le système écrit dans un buffer (une "todo list"). Quand le buffer est plein, il écrit vraiment sur le disque, ou alors quand on ferme le fichier.

fflush est un fonction qui force l'écrire :

int fflush( FILE * stream );

Quand on écrit dans un fichier, en fait, le système n'écrit pas directement dans le fichier, mais dans un tampon. Il écrit alors le contenu du tampon quand il est plein ou quand on ferme fichier. La fonction fflush force à écrire le contenu du tampon effectivement dans le fichier.

Un cas d'usage est l'écriture dans un fichier de log.

• Que fait l'instruction fflush(stdout); ?

Elle s'assure que tous les printf(..) et autres sur la sortie standard (la console) ont bien été affiché.

Se déplacer dans un fichier

La fonction fgetpos permet de sauvegarder la position courante dans une variable (on passe le pointeur en deuxième argument).

int fgetpos( FILE * stream, fpos_t * pos );

fpos_t pos;
if ( fgetpos(file, &pos) != 0 ) {
    fprintf(stderr, "Cannot access to the file position");
    fclose(file);
    exit(EXIT_FAILURE);
}

On peut ensuite revenir à cette position avec fsetpos :

int fsetpos( FILE * stream, fpos_t * pos );

Alternatives

On a aussi les fonctions :

long *ftell(FILE *stream)

donne la position courante depuis le début du fichier :

• en nombre d'octets si le fichier est ouvert en mode binaire
• en nombre de caractères si le fichier est ouvert en mode texte (ça dépend donc de l'encodage)

int *fseek(FILE *stream, long offset, int whence)

• Si whence == SEEK_SET (0), alors on se déplace de offset >= 0 depuis le début du fichier
• Si whence == SEEK_CUR (1) alors on se déplace de offset depuis la position courante
• Si whence == SEEK_END (2) alors on se déplace de offset <= 0 depuis la fin du fichier

• D'après vous que fait fseek(stdout, 2, SEEK_SET) ?

Ca marche pas si on écrit sur la console. Mais ça marche si la sortie standard écrit dans un fichier (avec une redirection...). Mais bon, c'est une mauvaise pratique.

Lecture/écriture de données

size_t
fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream)

• fread lit nitems éléments de size octets du fichier stream. Elle les écrit à l'adresse ptr.
• Elle renvoie le nombre d'éléments lus (a priorinitems, ou alors moins en cas de fin de fichier ou d'erreurs)

size_t
fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream)