Maîtriser les entrées/sorties de fichiers en C : Créer, ouvrir, lire, écrire et fermer des fichiers en toute confiance

Vue d'ensemble de la gestion des fichiers en C

En C, la bibliothèque standard stdio.h offre une suite complète de fonctions pour travailler avec des données persistantes sur disque. En maîtrisant ces outils, vous pouvez créer, lire, écrire et fermer des fichiers de manière fiable tout en assurant l'intégrité des données et la stabilité du programme.

Fonctions clés de gestion de fichiers

Fonction	But
fopen()	Ouvre un fichier existant ou en crée un nouveau.
fclose()	Ferme un fichier ouvert et libère les ressources.
fprintf()	Écrit du texte formaté dans un fichier.
fscanf()	Lit des données formatées depuis un fichier.
getc()	Récupère un seul caractère depuis un fichier.
putc()	Écrit un seul caractère dans un fichier.
fgets()	Lit une ligne entière dans un tampon.
fputs()	Écrit une chaîne dans un fichier sans formatage.
fseek()	Déplace le pointeur de fichier à un emplacement spécifié.
ftell()	Récupère la position actuelle du pointeur de fichier.
rewind()	Remet le pointeur de fichier au début.

Modes de fichier expliqués

Mode	Description
"r"	Ouvre en lecture ; échoue si le fichier n'existe pas.
"w"	Ouvre en écriture ; tronque le fichier existant ou en crée un nouveau.
"a"	Ouvre en ajout ; les écritures sont ajoutées à la fin du fichier.
"r+"	Ouvre en lecture et écriture depuis le début.
"w+"	Ouvre en lecture et écriture ; tronque le fichier existant.
"a+"	Ouvre en lecture et écriture ; ajoute les nouvelles données.

Créer un fichier

Pour créer ou ouvrir un fichier, vous déclarez d'abord un pointeur de fichier, puis appelez fopen() avec le nom de fichier et le mode souhaités :

FILE *fp;
fp = fopen("data.txt", "w");

Si le fichier n'existe pas, fopen() le crée. S'il existe déjà, le mode détermine si son contenu est préservé ou écrasé.

Vous pouvez aussi spécifier un chemin absolu :

fp = fopen("D:/data.txt", "w");

Images illustrant l'étape de création de fichier :

Fermer un fichier

Après avoir terminé toutes les opérations sur le fichier, appelez toujours fclose() pour libérer le descripteur de fichier et vider les tampons :

fp = fopen("data.txt", "r");
...
fclose(fp);

La fonction retourne 0 en cas de succès et EOF en cas d'erreur. Bien que le système d'exploitation ferme automatiquement les fichiers à la sortie du programme, la fermeture explicite est considérée comme une meilleure pratique.

Écrire dans un fichier

Lors de l'écriture, n'oubliez pas d'ajouter explicitement les caractères de nouvelle ligne (\n) là où c'est nécessaire. Voici les fonctions d'écriture les plus courantes :

• fputc(char, FILE*) – Écrit un seul caractère.
• fputs(const char*, FILE*) – Écrit une chaîne terminée par nul.
• fprintf(FILE*, const char*, …) – Écrit une sortie formatée.

Exemple : fputc()

#include <stdio.h>
int main() {
    int i;
    FILE *fptr;
    const char *str = "Guru99 Rocks\n";
    fptr = fopen("fputc_test.txt", "w");
    for (i = 0; str[i] != '\n'; i++) {
        fputc(str[i], fptr);
    }
    fclose(fptr);
    return 0;
}

Le fichier de sortie fputc_test.txt contient le texte :

Exemple : fputs()

#include <stdio.h>
int main() {
    FILE *fp = fopen("fputs_test.txt", "w+");
    fputs("This is Guru99 Tutorial on fputs,", fp);
    fputs("We don't need to use for loop\n", fp);
    fputs("Easier than fputc function\n", fp);
    fclose(fp);
    return 0;
}

Fichier résultant fputs_test.txt :

Exemple : fprintf()

#include <stdio.h>
int main() {
    FILE *fptr = fopen("fprintf_test.txt", "w");
    fprintf(fptr, "Learning C with Guru99\n");
    fclose(fptr);
    return 0;
}

Fichier résultant fprintf_test.txt :

Lire depuis un fichier

Trois fonctions principales lisent les données :

• fgetc(FILE*) – Retourne le caractère suivant.
• fgets(char*, int, FILE*) – Lit jusqu'à n-1 caractères dans un tampon.
• fscanf(FILE*, const char*, …) – Analyse une entrée formatée.

Voici une démonstration complète qui lit fprintf_test.txt en utilisant les trois méthodes :

#include <stdio.h>
int main() {
    FILE *fp;
    char buffer[50], c;
    fp = fopen("fprintf_test.txt", "r");
    printf("----read a line----\n");
    fgets(buffer, 50, fp);
    printf("%s\n", buffer);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read and parse data----\n");
    char str1[10], str2[2], str3[20], str4[2];
    fscanf(fp, "%s %s %s %s", str1, str2, str3, str4);
    printf("Read String1 |%s|\n", str1);
    printf("Read String2 |%s|\n", str2);
    printf("Read String3 |%s|\n", str3);
    printf("Read String4 |%s|\n", str4);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read the entire file----\n");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Sortie du programme :

----read a line----
Learning C with Guru99
----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

E/S caractère par caractère interactive avec getc et putc

Cet exemple minimal démontre la lecture de l'entrée utilisateur, son écriture dans un fichier, puis sa relecture :

#include <stdio.h>
int main() {
    FILE *fp;
    int c;
    printf("File Handling\n");
    fp = fopen("demo.txt", "w");
    while ((c = getchar()) != EOF) {
        putc(c, fp);
    }
    fclose(fp);
    printf("Data Entered:\n");
    fp = fopen("demo.txt", "r");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Exemple d'exécution :

Points à retenir

• Un fichier est un espace de stockage persistant sur disque.
• La bibliothèque standard C fournit fopen, fclose, fprintf, fscanf et fonctions associées pour une manipulation fiable des fichiers.
• Ouvrez toujours un fichier dans le mode correct pour contrôler le comportement de lecture, écriture ou ajout.
• Fermez explicitement les fichiers pour vider les tampons et libérer les ressources système.
• Utilisez fgetc et putc pour les flux de caractères simples, et fgets / fscanf pour l'entrée par ligne ou formatée.
• Lors de l'écriture, n'oubliez pas de terminer les chaînes avec \n si vous voulez des sauts de ligne.
• Une gestion d'erreurs appropriée (vérification des pointeurs NULL et valeurs de retour) est essentielle pour des applications robustes.