Maîtriser les entrées/sorties fichiers en C : Création, ouverture et gestion

Le chapitre précédent couvrait les périphériques standards. Celui-ci explique comment créer, ouvrir, fermer des fichiers texte ou binaires pour le stockage de données.

Un fichier = séquence d'octets (texte ou binaire). C offre des fonctions haut niveau et bas niveau (OS) pour la gestion. Voici les appels importants.

Ouverture de fichiers

FILE *fopen(const char *filename, const char *mode) : crée un nouveau fichier ou ouvre un existant. Initialise un objet FILE contenant les infos de contrôle du flux.

filename : nom du fichier. mode : valeurs possibles :

N°	Mode et description
1	r : ouvre fichier texte existant en lecture.
2	w : ouvre fichier texte en écriture. Crée s'il n'existe pas. Écrit au début (tronque).
3	a : ouvre fichier texte en écriture (ajout). Crée s'il n'existe pas. Ajoute à la fin.
4	r+ : ouvre fichier texte en lecture et écriture.
5	w+ : lecture/écriture. Tronque si existe, sinon crée.
6	a+ : lecture/écriture. Crée si n'existe pas. Lecture au début, écriture en ajout seulement.

Pour fichiers binaires, utilisez : "rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

Fermeture d'un fichier

int fclose(FILE *fp) : ferme le fichier. Retourne 0 si succès, EOF si erreur. Vide le tampon, ferme le fichier, libère la mémoire. EOF défini dans stdio.h.

Écriture dans un fichier

Écriture caractère par caractère :

int fputc(int c, FILE *fp);

Écrit le caractère c dans le flux fp. Retourne le caractère écrit ou EOF si erreur.

Écriture de chaîne :

int fputs(const char *s, FILE *fp);

Écrit la chaîne s dans fp. Retourne valeur non-négative si succès, EOF sinon.

Écriture formatée : int fprintf(FILE *fp, const char *format, ...).

Exemple complet écriture

#include <stdio.h>
int main() {
    FILE *fp = fopen("/tmp/test.txt", "w+");
    if (fp == NULL) { perror("Erreur ouverture"); return 1; }
    fprintf(fp, "Test fprintf...\n");
    fputs("Test fputs...\n", fp);
    fclose(fp);
    return 0;
}

Crée /tmp/test.txt avec deux lignes.

Lecture d'un fichier

Lecture caractère par caractère :

int fgetc(FILE *fp);

Retourne le caractère lu ou EOF si erreur/fin.

Lecture de chaîne :

char *fgets(char *buf, int n, FILE *fp);

Lit jusqu'à n-1 caractères, copie dans buf, ajoute \0. S'arrête au newline ou EOF (inclut le newline).

Lecture formatée : int fscanf(FILE *fp, const char *format, ...) — s'arrête au premier espace.

Exemple lecture

#include <stdio.h>
int main() {
    FILE *fp = fopen("/tmp/test.txt", "r");
    if (fp == NULL) { perror("Erreur ouverture"); return 1; }
    char buff[255];
    fscanf(fp, "%s", buff);
    printf("1 (fscanf) : %s\n", buff);  // lit "Test"
    fgets(buff, 255, fp);
    printf("2 (fgets)  : %s", buff);    // lit " fprintf...\n"
    fgets(buff, 255, fp);
    printf("3 (fgets)  : %s", buff);    // lit "Test fputs...\n"
    fclose(fp);
    return 0;
}

Résultat :

1 (fscanf) : Test
2 (fgets)  : fprintf...
3 (fgets)  : Test fputs...

Explication : fscanf s'arrête à l'espace après "Test". Premier fgets lit le reste de la ligne. Second fgets lit la ligne suivante complète.

Fonctions d'E/S binaire

Pour blocs de mémoire (tableaux, structures) :

size_t fread(void *ptr, size_t taille_élément, size_t nb_éléments, FILE *fichier);
size_t fwrite(const void *ptr, size_t taille_élément, size_t nb_éléments, FILE *fichier);

Utilisez ces fonctions pour lire/écrire des blocs — typiquement tableaux ou structures.