Entrées-sorties bufferisées

• Le système¹ fournit des primitives d’entrées/sorties (E/S) bufferisées
  • permet d’accéder au contenu de fichiers
  • bufferisées: les E/S sont d’abord groupées en mémoire, puis exécutées sur le périphérique
  • permet d’améliorer les performances
    • exemple: 1024 écritures de 1 octet sont regroupées en une écriture de 1ko (donc gain important en performances)
  • FILE*: type “opaque” désignant un fichier ouvert

¹ Pour être exact, il s’agit de la bibliothèque standard (la libc)

Ouverture/fermeture

• FILE* fopen(char* fichier, char* mode);

  • mode: mode d’ouverture

    • "r" : lecture seule
    • "w" : écriture seule
    • "r+" ou "a" : écriture seule (ajout)
    • "a+" : lecture et écriture (ajout)

• int fclose(FILE* f); * Complète les opérations et ferme le fichier

Primitives d’écriture

• int fprintf(FILE* f, char* format, ...);
  • similaire à printf, mais écrit dans le fichier f
  • écrit une chaîne de caractères dans un fichier
• size_t fwrite(void* ptr, size_t size, size_t nmemb, FILE* f);
  • écrit les size\(\times\)nmemb octets situés à l’adresse ptr dans f

fprintf(f, "%d", 12);

int n=12;
fwrite(&n, sizeof(int), 1, f);

fprintf(stderr, "Warning: flux capacitor overlow !\n");

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

int main(int argc, char**argv) {
  if (argc != 3) {
    fprintf(stderr, "USAGE = %s fichier_source fichier_destination\n", argv[0]);
    return EXIT_FAILURE;
  }

  /* open the input and output files */
  FILE*f =fopen(argv[1], "r");
  assert(f);
  FILE*f_out =fopen(argv[2], "w");
  assert(f_out);
  char line[1024];
  int lineno = 1;
  /* read the input file line by line */
  while(fgets(line, 1024, f)) {
    /* write the line to the output file */
    fprintf(f_out, "%s", line);
    lineno++;
  }

  /* close the files */
  fclose(f);
  fclose(f_out);
  return 0;
}

Primitives de lecture

• int fscanf(FILE* f, char* format, ...);
  • similaire à scanf, mais lit depuis le fichier f
• size_t fread(void* ptr, size_t size, size_t nmemb, FILE* f);
  • lit nmemb\(\times\)size octets et les stocke à l’adresse ptr
  • retourne le nombre d’items lus
  • fread renvoie une valeur < nmemb si la fin du fichier (EOF) est atteinte
• char* fgets(char* s, int size, FILE* f);
  • lit au plus size caractères et les stocke dans s
    • arrête la lecture avant size si lit n ou EOF

int a;
float b;
fscanf(f, "%d\t%f\n", &a, &b);

struct s {
  int a;
  float b;
  char c;
};
struct s tab[10];
fread(tab, sizeof(struct s), 10, f);

char line[1024];
int lineno = 1;
while(fgets(line, 1024, f)) {
  printf("line %d: %s\n", lineno, line);
  lineno++;
}

Curseur

• Position dans le fichier à laquelle la prochaine opération aura lieu

  • Initialisé à 0 (le début du fichier) généralement
  • sauf si ouvert en mode “a” ou “a+” (dans ce cas: positionné à la fin du fichier)

• Avance à chaque opération de lecture/écriture

• long ftell(FILE *stream);

  • Indique la position courante (en nombre d’octets depuis le début du fichier)

• int fseek(FILE *f, long offset, int whence);

  • déplace le curseur de offset octets depuis
    • le début du fichier (si whence vaut SEEK_SET)
    • la position courante (si whence vaut SEEK_CUR)
    • la fin du fichier (si whence vaut SEEK_END)