base_7.md

title: Base VII
date: 2020-11-11

Les fichier en C

• Un fichier en C est représenté par un pointeur de fichier.

  #include <stdio.h>
  FILE *fp;

• FILE *{.C} est une structure de donnée opaque contenant les informations sur l'état du fichier.

• Il est manipulé à l'aide de fonctions dédiées.

• Le pointeur de fichier est toujours passé par référence.

Manipulations de fichier

• Pour lire/écrire dans un fichier il faut toujours effectuer trois étapes:
  1. Ouvrir le fichier (fopen(){.C}).
  2. Écrire/lire dans le fichier (fgets(){.C}, fputs(){.C}, fread(){.C}, fwrite(){.C}, ...).
  3. Fermer le fichier (fclose(){.C}).
• Nous allons voir brièvement ces trois étapes.

Ouverture d'un fichier

• L'ouverture d'un fichier se fait avec la fonction fopen(){.C}

  FILE *fp = fopen(filename, mode);

• filename{.C} est une chaîne de caractères (incluant le chemin).

• mode{.C} est le mode d'ouverture ("r"{.C}, "w"{.C}, ... voir man 3 fopen{.bash}) qui est une chaîne de caractères.

• Si l'ouverture échoue (pas la bonne permission, ou n'existe pas) fopen(){.C} retourne 0.

• Toujours tester le retour de fopen(){.C}

  if (NULL == fp) {
      fprintf(stderr, "Can't open output file %s!\n", 
          filename); // affiche dans le canal d'erreur
      exit(RETURN_FAILURE);
  }

Fermeture d'un fichier

• Il faut toujours fermer un fichier à l'aide de fclose(){.C}

  FILE *fp = fopen("mon_fichier", "w");
  // écritures diverses
  fclose(fp);

• Les données sont transférées dans une mémoire tampon, puis dans le disques.

• Si la mémoire tampon est pleine, le fichier est fermé, ... les données sont écrites sur le disque.

• Si la mémoire tampon contient encore des données à la fin du programme les données sont perdues.

Lecture d'un fichier (1/2)

char *fgets(char *s, int size, FILE *stream)

• Lit une ligne de taille d'au plus size-1 et la stocke dans s, depuis stream.
• Retourne s ou NULL si échoue.

FILE *fp = fopen("text.txt", "r");
char buffer[100];
fgets(buffer, 37, fp);
// lit 36 caractères au plus et les écrit dans buffer
// s'arrête si rencontre EOF, ou "\n".
// ajoute un "\0" terminal
fclose(fp);

Lecture d'un fichier (2/2)

size_t fread(void *ptr, size_t size, size_t nmemb,
             FILE *stream)

• Lit nmemb éléments de taille size octets et les écrit à l'adresse ptr dans le fichier stream.

• Retourne le nombre d'éléments lus.

  FILE *fp = fopen("doubles.bin", "rb");
  double buffer[100];
  size_t num = fread(buffer, sizeof(double), 4, fp);
  // lit 4 double, se trouvant à l'adresse
  // buffer dans le fichier fp au format binaire
  // retourne 4
  fclose(fp);

Écriture dans un fichier (1/2)

int fprintf(FILE *stream, const char *format, ...)

• Écrit la chaîne de caractères format dans le fichier stream.

• format a la même syntaxe que pour printf().

• Retourne le nombre de caractères écrit sans le \0 terminal(si réussite).

  FILE *fp = fopen("text.txt", "w");
  fprintf(fp, "Hello world! We are in %d\n", 2020);
  // Écrit "Hello world! We are in 2020"
  // dans le fichier fp
  fclose(fp);

Écriture dans un fichier (2/2)

size_t fwrite(const void *ptr, size_t size,
              size_t nmemb, FILE *stream)

• Écrit nmemb éléments de taille size octets se trouvant à l'adresse ptr dans le fichier stream.

• Retourne le nombre d'éléments écrits.

  FILE *fp = fopen("doubles.bin", "wb");
  double buffer[] = {1.0, 2.0, 3.0, 7.0};
  size_t num = fwrite(buffer, sizeof(double), 4, fp);
  // écrit 4 double, se trouvant à l'adresse
  // buffer dans le fichier fp au format binaire
  // retourne 4
  fclose(fp);

Les pointeurs de fichiers spéciaux

• Il existe trois FILE *{.C} qui existent pour tout programme:

  • stdin{.C}: l'entrée standard.
  • stdout{.C}: la sortie standard.
  • stderr{.C}: l'erreur standard.

• Lors d'un fonctionnement dans le terminal:

  • l'entrée standard est le clavier
  • la sortie et erreur standard sont affichés dans le terminal.

• Ainsi on a

  fprintf(stdout, "texte\n"); // == printf("texte\n");
  int a;
  fscanf(stdin, "%d", &a); // == scanf("%d", &a);