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 :
| Mode | Description |
|---|---|
| r | Ouvre un fichier texte existant en lecture. |
| w | Ouvre 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). |
| a | Ouvre 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
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
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
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 :
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 <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
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 <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
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
// 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 <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
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
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) |