Les fichiers binaires en langage C

Ce laboratoire pratique porte sur la manipulation des fichiers binaires en langage C. Il permet d'apprendre à écrire, lire, afficher et modifier des données stockées dans des fichiers binaires, en utilisant les fonctions standards du langage C telles que fwrite, fread, fopen, fclose, fseek, ftell et feof. Pour réaliser ce TP, il est nécessaire de disposer d'un environnement de programmation C avec un compilateur compatible et d'avoir des connaissances de base en gestion de fichiers et en structures de données en C.

Objectifs

• Comprendre la différence entre fichiers binaires et fichiers texte en C.
• Utiliser les fonctions fwrite et fread pour écrire et lire des données binaires.
• Gérer l'ouverture et la fermeture de fichiers avec fopen et fclose.
• Utiliser les fonctions feof et fseek pour détecter la fin de fichier et accéder directement à une position dans un fichier.
• Manipuler des structures complexes (exemple : structure ETUDIANT) dans des fichiers binaires.
• Modifier des enregistrements dans un fichier binaire en utilisant l'accès direct.

Prérequis et installation

• Connaissances de base en langage C, notamment sur les pointeurs, les structures et les entrées/sorties.
• Un compilateur C (gcc, clang, ou autre) et un éditeur de texte.
• Bibliothèque standard C (stdio.h, stdlib.h) disponible.
• Compréhension des notions de fichiers, flux, et gestion mémoire.

Manipulation des fichiers binaires : ouverture, écriture et lecture

Dans cette étape, vous allez apprendre à ouvrir un fichier en mode binaire, écrire des entiers dans ce fichier, puis les relire et les afficher.

La fonction fopen permet d'ouvrir un fichier et d'obtenir un pointeur de type FILE* qui représente un flux vers ce fichier. Le mode d'ouverture « wb+ » signifie que le fichier est ouvert en mode binaire pour lecture et écriture, et qu'il est créé s'il n'existe pas ou vidé s'il existe déjà.

La fonction fwrite permet d'écrire des blocs de données binaires dans le fichier, tandis que fread permet de lire ces blocs.

#include <stdio.h>

void main() {
  char nomfich[21];
  int n;
  FILE *fp;

  printf("saisir nom fichier ");
  scanf("%s", nomfich);
  fp = fopen(nomfich, "wb+");
  do {
    printf("donner un entier; 0 pour s'arreter  ");
    scanf("%d", &n);
    if (n != 0) fwrite(&n, sizeof(int), 1, fp);
  } while (n != 0);

  rewind(fp);

  while (!feof(fp)) {
    fread(&n, sizeof(int), 1, fp);
    if (!feof(fp)) printf("\n  %d\n", n);
  }

  fclose(fp);
}

Ce qu'il faut faire :

• Compiler et exécuter ce programme.
• Saisir un nom de fichier.
• Entrer une série d'entiers, terminer par 0.
• Observer l'affichage des entiers lus depuis le fichier.

Pourquoi : Cet exercice montre comment écrire et lire des données binaires dans un fichier, ainsi que l'utilisation de rewind pour revenir au début du fichier avant la lecture.

Résultat correct : Les entiers saisis (hors 0) doivent être affichés dans le même ordre après la lecture.

Gestion avancée des fichiers binaires avec structures

Cette étape consiste à manipuler des fichiers binaires contenant des enregistrements complexes, ici des étudiants définis par une structure contenant un numéro, un nom, un tableau de notes et une date de naissance.

struct date {
  int jour;
  int mois;
  int annee;
};
typedef struct date DATE;

struct etudiant {
  int ce;           // numéro carte d’étudiant
  char nom[30];
  float notes[5];
  DATE date_naiss;
};
typedef struct etudiant ETUDIANT;

Le programme propose des fonctions pour :

• Ouvrir un fichier en mode binaire pour lecture et écriture.
• Saisir les notes d'un étudiant.
• Saisir les informations complètes d'un étudiant avec condition d'arrêt ce = -1.
• Écrire les étudiants dans le fichier avec fwrite.
• Lire et afficher les étudiants depuis le fichier avec fread et feof.

Exemple d'utilisation :

void ouverture(FILE **fp) {
  char nf[20];
  printf("saisir nom fichier ");
  gets(nf);
  *fp = fopen(nf, "wb+");
}

int saisir_etudiant(ETUDIANT *e) {
  printf("\n saisir ce \n");
  scanf("%d", &e->ce);
  if (e->ce == -1) return 0;
  printf("\n saisir nom    ");
  scanf("%s", e->nom);
  printf("\n saisir les notes ");
  remplir_notes(e->notes);
  printf("\n saisir la date de naissance \n");
  scanf("%d%d%d", &e->date_naiss.jour, &e->date_naiss.mois, &e->date_naiss.annee);
  return 1;
}

void remplir_fichier(FILE *fp) {
  ETUDIANT etd;
  while (saisir_etudiant(&etd))
    fwrite(&etd, sizeof(ETUDIANT), 1, fp);
}

void affichage_fichier(FILE *fp) {
  ETUDIANT etd;
  while (1) {
    fread(&etd, sizeof(ETUDIANT), 1, fp);
    if (feof(fp)) break;
    printf("\n  %4d %20s \n", etd.ce, etd.nom);
    afficher_notes(etd.notes);
    printf("\n  %2d %2d %4d \n", etd.date_naiss.jour, etd.date_naiss.mois, etd.date_naiss.annee);
  }
}

void main() {
  FILE *fp;
  ouverture(&fp);
  remplir_fichier(fp);
  rewind(fp);
  affichage_fichier(fp);
  fclose(fp);
}

Ce qu'il faut faire :

• Compiler et exécuter ce programme.
• Saisir les informations des étudiants jusqu'à ce = -1.
• Observer l'affichage des étudiants lus depuis le fichier.

Pourquoi : Cet exercice montre la gestion de structures complexes dans un fichier binaire et la lecture séquentielle jusqu'à la fin du fichier.

Résultat correct : Tous les étudiants saisis doivent être affichés avec leurs notes et date de naissance.

Accès direct et modification d'enregistrements dans un fichier binaire

Cette étape montre comment accéder directement à un enregistrement dans un fichier binaire pour le modifier, sans parcourir tous les enregistrements précédents.

La fonction fseek permet de positionner le pointeur de fichier à une position donnée en octets, ce qui permet un accès direct.

fseek(fp, (pos-1) * sizeof(ETUDIANT), SEEK_SET);

Exemple de programme pour modifier un étudiant à une position donnée :

void modifier_etudiant(ETUDIANT *e) {
  printf("\n saisir les nouvelles infos de l'etudiant \n");
  printf("\n saisir ce \n");
  scanf("%d", &e->ce);
  printf("\n saisir nom    ");
  scanf("%s", e->nom);
  printf("\n saisir les notes ");
  remplir_notes(e->notes);
  printf("\n saisir la date de naissance \n");
  scanf("%d%d%d", &e->date_naiss.jour, &e->date_naiss.mois, &e->date_naiss.annee);
}

void main() {
  FILE *fp;
  int pos;
  long p;
  ETUDIANT etd;

  ouverture(&fp);
  remplir_fichier(fp);
  rewind(fp);

  printf("saisir la position de l'etudiant à modifier ");
  scanf("%d", &pos);

  fseek(fp, (pos-1) * sizeof(ETUDIANT), SEEK_SET);
  p = ftell(fp);
  fread(&etd, sizeof(ETUDIANT), 1, fp);
  afficher_etudiant(etd);
  modifier_etudiant(&etd);
  fseek(fp, p, SEEK_SET);
  fwrite(&etd, sizeof(ETUDIANT), 1, fp);

  rewind(fp);
  affichage_fichier(fp);
  fclose(fp);
}

Ce qu'il faut faire :

• Compiler et exécuter ce programme.
• Entrer les étudiants comme précédemment.
• Entrer la position de l'étudiant à modifier.
• Modifier ses données.
• Observer la mise à jour dans le fichier.

Pourquoi : Cette étape illustre l'accès direct à un enregistrement dans un fichier binaire et la modification sans réécrire tout le fichier.

Résultat correct : L'étudiant à la position choisie doit être modifié et les autres restent inchangés.

Résultats attendus

• Les entiers ou structures écrits dans un fichier binaire sont lus et affichés correctement dans le même ordre.
• La détection de fin de fichier avec feof fonctionne correctement : la lecture s'arrête après la dernière donnée.
• La fonction fseek permet de positionner précisément le pointeur de fichier pour un accès direct.
• Les modifications d'un enregistrement dans un fichier binaire sont bien prises en compte et visibles à la lecture suivante.

Pièges courants

• Ne pas vérifier que fopen a réussi à ouvrir le fichier (pointeur nul).
• Confondre les modes d'ouverture : « wb+ » écrase le fichier existant, « rb+ » ouvre en lecture/écriture sans écraser.
• Utiliser feof avant une lecture : feof ne devient vrai qu'après une tentative de lecture au-delà de la fin.
• Ne pas utiliser rewind ou fseek avant de relire un fichier déjà écrit, ce qui conduit à ne rien lire.
• Confondre les arguments de fwrite et fread : nombre de blocs et taille des blocs doivent être cohérents.
• Ne pas gérer correctement la taille des structures, notamment en cas de padding ou d'alignement.
• Utiliser gets() sans précaution peut provoquer des débordements de tampon (attention à remplacer par fgets dans un vrai projet).