Merge branch cours:master into master

slides/fichiers.md

+---
+title: "Lecture/écriture de fichiers"
+date: "2023-12-14"
+---
+
+# Les fichier en C
+
+* Un fichier en C est représenté par un pointeur de fichier.
+
+    ```C
+    #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 copie*.
+
+
+# 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}
+
+    ```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}
+
+    ```C
+    if (NULL == fp) {
+        fprintf(stderr, "Can't open output file %s!\n", 
+            filename); // affiche dans le canal d'erreur
+        exit(EXIT_FAILURE);
+    }
+    ```
+
+# Fermeture d'un fichier
+
+* Il faut **toujours** fermer un fichier à l'aide de `fclose()`{.C}
+
+    ```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)
+
+```C
+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.
+
+```C
+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)
+
+```C
+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.
+
+    ```C
+    FILE *fp = fopen("doubles.bin", "rb");
+    double buffer[100];
+    size_t num = fread(buffer, sizeof(double), 4, fp);
+    // lit 4 double, se trouvant dans le fichier fp au 
+    // format binaire et les écrit dans buffer, puis
+    // retourne 4
+    fclose(fp);
+    ```
+
+# Écriture dans un fichier (1/2)
+
+```C
+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).
+
+    ```C
+    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)
+
+```C
+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.
+
+    ```C
+    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
+  
+    ```C
+    fprintf(stdout, "texte\n"); // == printf("texte\n");
+    int a;
+    fscanf(stdin, "%d", &a); // == scanf("%d", &a);
+    ```
+