C E/S de fichiers

Dans le chapitre précédent, nous avons expliqué comment le langage C gère les périphériques d'entrée et de sortie standard. Ce chapitre présentera comment les programmeurs C créent, ouvrent et ferment des fichiers texte ou des fichiers binaires.

Un fichier, qu'il s'agisse d'un fichier texte ou d'un fichier binaire, représente une série d'octets. Le langage C fournit non seulement des fonctions de haut niveau, mais aussi des appels de bas niveau (OS) pour gérer les fichiers sur les périphériques de stockage. Ce chapitre expliquera les appels importants pour la gestion de fichiers.

Ouvrir un fichier

Vous pouvez utiliserfopen( )La fonction utilisée pour créer un nouveau fichier ou ouvrir un fichier existant. Cet appel initialise un typeFILEun objet de typeFILEqui contient toutes les informations nécessaires pour contrôler le flux. Voici le prototype de cet appel de fonction :

FILE *fopen( const char *filename, const char *mode );

Ici,filenameest une chaîne utilisée pour nommer le fichier ; le mode d'accèsmodeLa valeur peut être l'une des valeurs suivantes :

ModeDescription
rOuvre un fichier texte existant en lecture.
wOuvre un fichier texte en écriture. Si le fichier n'existe pas, un nouveau fichier est créé. Ici, votre programme écrira le contenu depuis le début du fichier. Si le fichier existe, son contenu est effacé (c'est-à-dire que la longueur du fichier est tronquée à 0).
aOuvre un fichier texte en écriture en mode ajout. Si le fichier n'existe pas, un nouveau fichier est créé. Ici, votre programme ajoutera du contenu au contenu existant du fichier.
r+Ouvre un fichier texte à la fois en lecture et en écriture.
w+Ouvre un fichier texte à la fois en lecture et en écriture. Si le fichier existe déjà, il sera tronqué à une longueur nulle ; si le fichier n'existe pas, un nouveau fichier sera créé.
a+Ouvre un fichier texte à la fois en lecture et en écriture. Si le fichier n'existe pas, un nouveau fichier sera créé. La lecture commence au début du fichier, tandis que l'écriture ne peut se faire qu'en mode ajout.

Si vous avez affaire à des fichiers binaires, utilisez les modes d'accès suivants pour remplacer les modes d'accès ci-dessus :

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

Fermer un fichier

Pour fermer un fichier, utilisez la fonction fclose( ). Le prototype de la fonction est le suivant :

 int fclose( FILE *fp );

Si le fichier est fermé avec succès,fclose( )La fonction renvoie zéro ; si une erreur se produit lors de la fermeture du fichier, la fonction renvoieEOFEOF. Cette fonction vide en fait les données du tampon, ferme le fichier et libère toute la mémoire utilisée pour le fichier. EOF est défini dans le fichier d'en-têtestdio.hla constante dans.

La bibliothèque standard C fournit diverses fonctions pour lire et écrire des fichiers caractère par caractère ou sous forme de chaînes de longueur fixe.

Écrire dans un fichier

Voici la fonction la plus simple pour écrire un caractère dans un flux :

int fputc( int c, FILE *fp );

La fonctionfputc()écrit la valeur du caractère du paramètre c dans le flux de sortie pointé par fp. En cas de succès, elle renvoie le caractère écrit ; si une erreur se produit, elle renvoieEOFVous pouvez utiliser la fonction suivante pour écrire une chaîne terminée par un caractère nul dans un flux :

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

La fonctionfputs()écrit la chaînesdans le flux de sortie pointé par fp. En cas de succès, elle renvoie une valeur non négative ; si une erreur se produit, elle renvoieEOFVous pouvez aussi utiliserint fprintf(FILE *fp,const char *format, ...)La fonction écrit une chaîne dans le fichier. Essayez l'exemple suivant :

Remarque :Veuillez vous assurer que vous disposez d'un répertoiretmputilisable. Si le répertoire n'existe pas, vous devez d'abord le créer sur votre ordinateur.

/tmpIl s'agit généralement du répertoire temporaire sur les systèmes Linux. Si vous exécutez sous Windows, vous devez le remplacer par un répertoire existant dans votre environnement local, par exemple : C:\tmp、D:\tmpetc.

Exemple

#include <stdio.h> int main() { FILE *fp = NULL; fp = fopen("/tmp/test.txt", "w+"); fprintf(fp, "Ceci est un test pour fprintf...\n"); fputs("Ceci est un test pour fputs...\n", fp); fclose(fp); }

Lorsque le code ci-dessus est compilé et exécuté, il crée un nouveau fichier dans le répertoire /tmptest.txtet utilise deux fonctions différentes pour écrire deux lignes. Ensuite, lisons ce fichier.

Lire depuis un fichier

Voici la fonction la plus simple pour lire un seul caractère depuis un fichier :

int fgetc( FILE * fp );

fgetc()La fonction lit un caractère dans le fichier d'entrée pointé par fp. La valeur de retour est le caractère lu ; si une erreur se produit, elle renvoieEOFLa fonction suivante permet de lire une chaîne depuis un flux :

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

Fonctionfgets()Elle lit n - 1 caractères depuis le flux d'entrée pointé par fp. Elle copie la chaîne lue dans le tamponbuf, et ajoute uncaractèrenul pour terminer la chaîne.

Si cette fonction rencontre un saut de ligne '\n' ou la fin de fichier EOF avant de lire le dernier caractère, elle renvoie uniquement les caractères lus, y compris le saut de ligne. Vous pouvez également utiliserint fscanf(FILE *fp, const char *format, ...)fonction pour lire des chaînes depuis un fichier, mais elle s'arrête de lire lorsqu'elle rencontre le premier espace ou saut de ligne.

Exemple

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

Lorsque le code ci-dessus est compilé et exécuté, il lit le fichier créé dans la section précédente et produit les résultats suivants :

1: This
2: is testing for fprintf...

3: This is testing for fputs...

Tout d'abord,fscanf()La méthode n'a lu queThiscar elle a rencontré un espace ensuite. Ensuite, appelezfgets()pour lire la partie restante jusqu'à la fin de la ligne. Enfin, appelezfgets()Lit complètement la deuxième ligne.

Fonctions d'E/S binaires

Les deux fonctions suivantes sont utilisées pour l'entrée et la sortie binaires :

size_t fread(void *ptr, size_t size, size_t count, FILE *stream);
size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);

freadetfwritesont les fonctions principales de la bibliothèque standard C pour la lecture et l'écriture de blocs de fichiers binaires. Elles opèrent directement sur des blocs de données en mémoire, évitant la surcharge de conversion au format texte, et conviennent particulièrement à la lecture et à l'écriture par lots de fichiers volumineux et de données structurées.

Description des paramètres

Les quatre paramètres ont la même signification dans les deux fonctions, mais le sens du flux de données est opposé :

Paramètre Type Description Comportement de fread Comportement de fwrite
ptr void* / const void* Pointeur vers le tampon mémoire Adresse de destination de lecture (écriture en mémoire) Adresse source des données (lecture depuis la mémoire)
size size_t Nombre d'octets par bloc de données Taille du bloc par lecture Taille du bloc par écriture
count size_t Nombre de blocs de données à lire ou à écrire Nombre attendu de blocs à lire Nombre attendu de blocs à écrire
flux FILE* Pointeur de fichier ouvert Doit être ouvert avec "rb" Doit être ouvert avec "wb"

Le nombre réel d'octets traités estsize × countla valeur de retour est le nombre de blocs lus ou écrits avec succès, et non le nombre d'octets. Si la valeur de retour est inférieure à count, cela peut être dû à une fin de fichier (EOF) ou à une erreur de lecture/écriture, qu'il convient de vérifier séparément.

Mode binaire vs. mode texte

Lors de l'utilisation de fread/fwrite, vous devez ouvrir le fichier en mode binaire ; sinon, une corruption des données peut se produire.

Pourquoi le mode binaire doit être utilisé

Le mode texte sous Windows convertit automatiquement les caractères de nouvelle ligne\nconvertis en\r\n, ce qui détruira l'intégrité des données binaires.

Sous Linux/macOS, le mode texte et le mode binaire se comportent de la même manière, mais le code multiplateforme doit explicitement utiliser"b"flag pour garantir la portabilité.

Exemple

// Manière correcte : spécifier explicitement le mode binaire
FILE *fp_read  = fopen("data.bin", "rb");  // Lecture binaire
FILE *fp_write = fopen("data.bin", "wb");  // Écriture binaire

// Mauvaise approche : mode texte (les données peuvent être corrompues sous Windows)
FILE *fp_bad = fopen("data.bin", "r");     // Indicateur "b" manquant

Comparaison avec les fonctions textuelles

La fonction à choisir dépend du type de données et du scénario requis :

Fonctionnalités fread / fwrite fprintf / fscanf
Méthode de traitement des données Lire et écrire les données binaires en mémoire telles quelles Conversion basée sur le format (nombre ↔ chaîne)
Scénarios applicables Structures, tableaux, images, audio, etc. Texte lisible par l'humain, comme les fichiers de configuration, les journaux, les rapports, etc.
Performance Rapide, aucun surcoût de conversion Lent, vous devez analyser la chaîne de format
Precision Aucune perte de précision Les nombres à virgule flottante peuvent perdre de la précision
Lisible par l'humain Non (format binaire) Oui (format texte brut)

Diagramme de flux de lecture/écriture des données

La figure suivante montre le flux de données entre fread et fwrite, ainsi qu'entre le fichier et la mémoire :

fread/fwrite 数据读写流程

Scénarios d'utilisation typiques

Lecture et écriture de données de structure

C'est le scénario d'application le plus courant de fread/fwrite ; vous pouvez lire ou écrire une structure entière en un seul bloc de données à la fois.

Exemple

#include <stdio.h>
#include <stdlib.h>

// Définir la structure étudiant
// Remarque : doit utiliser un tableau de longueur fixe, ne peut pas utiliser le membre pointeur char *name
typedef struct {
    int id;             // Identifiant étudiant
    char name[50];      // Nom (tableau de longueur fixe, pointeur non autorisé)
    float score;        // Note
} Student;

int main() {
    // ===== Écrire la structure dans le fichier =====
    Student s = {101, "Alice", 95.5f};  // Initialiser les données
    FILE *fp = fopen("student.bin", "wb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }
    // Écrire toute la structure comme un seul bloc de données
    size_t written = fwrite(&s, sizeof(Student), 1, fp);
    if (written != 1) {
        printf("Échec de l'écriture\n");
    }
    fclose(fp);

    // ===== Lire la structure depuis le fichier =====
    fp = fopen("student.bin", "rb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }
    Student loaded;  // Non initialisé, sera rempli par fread
    size_t read_count = fread(&loaded, sizeof(Student), 1, fp);
    if (read_count != 1) {
        printf("Échec de lecture ou fin de fichier\n");
        fclose(fp);
        return 1;
    }
    printf("ID: %d, Nom: %s, Score: %.1f\n", chargé.id, chargé.name, chargé.score);
    fclose(fp);
    return 0;
}
学号: 101, 姓名: Alice, 成绩: 95.5

Les structures ne peuvent pas contenir de membres pointeurs (commechar name), car fwrite enregistre uniquement l'adresse du pointeur, pas le contenu de la chaîne vers laquelle il pointe. Lors de la relecture, cette adresse n'est plus valide, ce qui produit un pointeur suspendu. La bonne pratique consiste à utiliser un tableau de longueur fixe, tel quechar name[50]。

Lecture et écriture de données de tableau

Les tableaux sont stockés de manière contiguë en mémoire, de sorte que l'ensemble du tableau peut être lu ou écrit en une seule fois.

Exemple

#include <stdio.h>

int main() {
    // Tableau de données brutes
    int data[] = {1, 2, 3, 4, 5};
    int count = 5;  // Nombre d'éléments du tableau

    // ===== Écrire le tableau dans un fichier =====
    FILE *fp = fopen("array.bin", "wb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }
    // data est équivalent à &data[0], pointant vers la première adresse du tableau
    fwrite(data, sizeof(int), count, fp);
    fclose(fp);
    printf("%d entiers écrits dans array.bin\n", count);

    // ===== Lire le tableau depuis le fichier =====
    int buffer[5] = {0};  // Initialiser à 0 pour faciliter la vérification des résultats de lecture
    fp = fopen("array.bin", "rb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }
    size_t read_count = fread(buffer, sizeof(int), count, fp);
    if (read_count < count) {
        printf("Lecture incomplète : %d éléments attendus, %zu éléments obtenus"\n", count, read_count);
    }
    fclose(fp);

    // Afficher le résultat de lecture
    printf("Données lues : ");
    for (int i = 0; i < count; i++) {
        printf("%d ", buffer[i]);
    }
    printf("\n");
    return 0;
}
已写入 5 个整数到 array.bin
读取到的数据: 1 2 3 4 5

Lecture et écriture par lots de fichiers volumineux

Pour les fichiers volumineux, vous devez utiliser une boucle pour lire/écrire par blocs, en évitant de charger tout le contenu en mémoire d'un seul coup.

Exemple

#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 1024 // Lire/écrire 1KB à chaque fois, ajustez selon les besoins

// Fonction efficace de copie de fichier
// Valeur de retour : 0 indique le succès, -1 indique l'échec
int copy_file(const char *src, const char *dst) {
    char buffer[BUFFER_SIZE];  // Tampon intermédiaire
    FILE *in = fopen(src, "rb");
    FILE *out = fopen(dst, "wb");

    // Vérifier si les deux fichiers ont été ouverts avec succès
    if (!in) {
        perror("Échec de l'ouverture du fichier source");
        return -1;
    }
    if (!out) {
        perror("Échec de l'ouverture du fichier cible");
        fclose(in);   // Fermer le fichier source ouvert
        return -1;
    }

    // Lire en boucle, jusqu'à BUFFER_SIZE octets à chaque fois
    size_t n;
    while ((n = fread(buffer, 1, BUFFER_SIZE, in)) > 0) {
        // fwrite avec size=1, count=n garantit que le nombre réel d'octets lus est écrit
        if (fwrite(buffer, 1, n, out) != n) {
            perror("Échec de l'écriture");
            fclose(in);
            fclose(out);
            return -1;
        }
    }

    // Vérifier si la lecture s'est terminée en raison d'une erreur (plutôt qu'une fin de fichier normale)
    if (ferror(in)) {
        perror("Erreur de lecture");
        fclose(in);
        fclose(out);
        return -1;
    }

    fclose(in);
    fclose(out);
    printf("Fichier copié avec succès : %s -> %s\n"\n", src, dst);
    return 0;
}

int main() {
    // Exemple d'utilisation : copier le fichier de test d'exemple
    copy_file("example_input.bin", "example_output.bin");
    return 0;
}
文件复制成功: example_input.bin -> example_output.bin

La clé de ce mode estfreadRenvoie le nombre réel d'octets lus, puis utilisezfwritepour écrire uniquement le nombre d'octets réellement lus, en évitant d'écrire des données supplémentaires à la fin.

Considérations clés

Vérification de la valeur de retour

Après avoir appelé fread/fwrite, vous devez vérifier la valeur de retour pour distinguer une terminaison normale de conditions anormales.

Exemple

#include <stdio.h>

int main() {
    int buffer[100];
    FILE *fp = fopen("data.bin", "rb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }

    // Essayer de lire 100 entiers
    size_t count = fread(buffer, sizeof(int), 100, fp);

    if (count < 100) {
        // Distinguer EOF des erreurs
        if (feof(fp)) {
            printf("Fin de fichier atteinte, %zu éléments réellement lus\n"\n", count);
            // À ce stade, nous pouvons continuer à traiter les données lues
        } else if (ferror(fp)) {
            perror("Une erreur s'est produite lors de la lecture");
            fclose(fp);
            return 1;
        }
    } else {
        printf("Tous les %zu éléments ont été lus avec succès\n", count);
    }

    fclose(fp);
    return 0;
}
已到达文件末尾,实际读取 47 个元素

Pièges de lecture/écriture de structures

La disposition mémoire des structures est affectée par la stratégie d'alignement du compilateur, ce qui peut entraîner des problèmes de compatibilité entre plateformes.

Incohérence d'alignement mémoire

Avec différents compilateurs ou différentes options de compilation, la même structure peut avoir des dispositions mémoire différentes.

Exemple

#include <stdio.h>

// Exemple de problème : avec l'alignement par défaut, il y aura 3 octets de remplissage après char
typedef struct {
    char c;      // Occupe 1 octet, mais il y a du remplissage après lui
    int i;       // Alignement sur 4 octets, commence en fait à l'offset 4
} Mixed;

// Solution 1 : utiliser pragma pack pour forcer un alignement compact
#pragma pack(push, 1) // Enregistre les paramètres d'alignement actuels, définit l'alignement sur 1 octet
typedef struct {
    char c;      // Offset 0, occupe 1 octet
    int i;       // Offset 1, occupe 4 octets (pas de remplissage)
} PackedMixed;
#pragma pack(pop) // Restaure les paramètres d'alignement précédents

// Solution 2 : sérialiser manuellement les membres un par un (la méthode la plus sûre)
// Cette méthode ne dépend pas de l'alignement du compilateur et offre la meilleure compatibilité multiplateforme

int main() {
    // Afficher la différence de taille entre les deux structures
    printf("Taille de Mixed alignée par défaut : %zu octets\n", sizeof(Mixed));       // Généralement 8
    printf("Taille de PackedMixed alignée de manière compacte : %zu octets\n", sizeof(PackedMixed)); // Il est de 5
    return 0;
}
默认对齐 Mixed 大小: 8 字节
紧凑对齐 PackedMixed 大小: 5 字节

Pratique recommandéePour une utilisation multiplateforme ou un stockage à long terme, préférez la sérialisation manuelle (lecture/écriture membre par membre) à l'écriture directe de la structure dans un fichier. Cela permet d'éviter complètement les problèmes d'alignement et d'ordre des octets.

Les membres pointeurs sont interdits

C'est l'une des erreurs les plus courantes commises par les débutants.

Exemple

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Exemple incorrect : la structure contient un membre pointeur
typedef struct {
    int id;
    char *name;   // Danger ! fwrite n'enregistre que la valeur du pointeur (l'adresse), pas le contenu de la chaîne
} BadStudent;

// Exemple correct : utiliser un tableau de taille fixe
typedef struct {
    int id;
    char name[100];  // Les données réelles sont stockées dans la structure, elles peuvent donc être lues et écrites en toute sécurité
} GoodStudent;

int main() {
    // Démontrer les conséquences de la mauvaise approche
    BadStudent bs;
    bs.id = 1;
    bs.name = malloc(50);
    strcpy(bs.name, "EXAMPLE");

    // Écrire BadStudent : à ce stade, l'adresse du pointeur name est écrite, mais le contenu de la chaîne n'est pas écrit
    FILE *fp = fopen("bad.bin", "wb");
    fwrite(&bs, sizeof(BadStudent), 1, fp);
    fclose(fp);

    // Relire BadStudent : la valeur du pointeur name est l'adresse d'un malloc précédent dans un autre processus, complètement invalide
    BadStudent chargé;
    fp = fopen("bad.bin", "rb");
    fread(&loaded, sizeof(BadStudent), 1, fp);
    fclose(fp);
    // loaded.name est un pointeur suspendu ; y accéder entraîne un comportement indéfini !

    free(bs.name);
    printf("Démo terminée, mais le pointeur name chargé est invalide\n");
    return 0;
}
演示完成,但 load 出来的 name 指针是无效的

Vidage du tampon

Les E/S de la bibliothèque standard C sont tamponnées ; les données critiques doivent être vidées explicitement pour garantir leur persistance.

Exemple

#include <stdio.h>

int main() {
    FILE *fp = fopen("critical.bin", "wb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }

    int data[] = {1, 2, 3, 4, 5};
    fwrite(data, sizeof(int), 5, fp);

    // Méthode 1 : vider explicitement le tampon, les données sont immédiatement écrites sur le disque
    fflush(fp);
    printf("Utilisez fflush pour forcer l'écriture sur disque\n");

    // Méthode 2 : Vidage automatique à la fermeture du fichier (recommandée)
    // fclose appelle automatiquement fflush en interne
    fclose(fp);
    printf("fclose vide aussi automatiquement le tampon\n");

    return 0;
}
使用 fflush 强制刷新到磁盘
fclose 也会自动刷新缓冲区

Positionnement du pointeur de fichier

La combinaison de fseek et ftell permet un accès aléatoire à un fichier, en lisant les données aux positions spécifiées selon les besoins.

Exemple

#include <stdio.h>

typedef struct {
    int id;
    char name[50];
    float score;
} Student;

int main() {
    FILE *fp = fopen("students.bin", "rb");
    if (fp == NULL) {
        perror("Échec de l'ouverture du fichier");
        return 1;
    }

    // Aller à la fin du fichier pour obtenir la taille du fichier
    fseek(fp, 0, SEEK_END);
    long file_size = ftell(fp);
    printf("Taille du fichier : %ld octets\n", file_size);

    // Calculer combien d'enregistrements de type struct se trouvent dans le fichier
    long record_count = file_size / sizeof(Student);
    printf("Contient %ld enregistrements d'étudiants\n", record_count);

    // Passer au 6e enregistrement struct (l'index commence à 0, décalage = 5 * sizeof(Student))
    fseek(fp, sizeof(Student) * 5, SEEK_SET);
    Student s;
    fread(&s, sizeof(Student), 1, fp);
    printf("Enregistrement #6 : id=%d, name=%s\n", s.id, s.name);

    fclose(fp);
    return 0;
}
文件大小: 6000 字节
包含 100 条学生记录
第 6 条记录: id=106, name=EXAMPLE

Résumé des erreurs courantes

Le tableau suivant résume les problèmes les plus courants et les bonnes pratiques lors de l'utilisation de fread/fwrite :

Type d'erreur Symptôme d'erreur Approche correcte
Pointeur de fichier non vérifié Appeler fread directement après l'échec de fopen, provoquant un plantage. Toujours vérifierfp != NULL
Ignorer le mode binaire Données binaires corrompues par la conversion des retours à la ligne sous Windows. Utilisation"rb" / "wb"
Confondre le nombre de blocs avec le nombre d'octets Traiter la valeur de retour comme le nombre d'octets, provoquant des erreurs logiques. Rappelez-vous que la valeur de retour est le nombre de blocs ; nombre d'octets =Valeur de retour × taille
Débordement de tampon Espace alloué insuffisant, écriture hors limites Assurez-vous que l'espace du tampon est ≥size × count
La structure contient des pointeurs L'adresse du pointeur est invalide après relecture, ce qui entraîne un pointeur suspendu. Utilisez un tableau fixe ou sérialisez manuellement chaque membre.
Ignorer les vérifications d'erreur Échec de la distinction entre EOF et les erreurs de lecture, entraînant des données incomplètes. Vérifiez la valeur de retour, utilisezfeof() / ferror()Déterminez la cause
Données non synchronisées Un plantage du programme entraîne une perte des données du tampon Après avoir écrit des données critiques, appelezfflush(fp)
autres extensions