From c312c3594a3c3bdab5cef4d0935e8c80e7edaca1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicolas=20M=2E=20Thi=C3=A9ry?= <nthiery@users.sf.net>
Date: Sun, 3 Nov 2024 23:21:00 +0100
Subject: [PATCH] =?UTF-8?q?Pr=C3=A9paration?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gradebook.db                       | Bin 176128 -> 176128 bytes
 TD.md                               |   6 +--
 cours-etat-fichier.md               |  61 +++++++++++++++-------------
 cours-fichiers.md                   |  49 +++++++++++++++++-----
 cours-flux-chaines-de-caracteres.md |  27 ++++++------
 cours-flux.md                       |  10 ++---
 6 files changed, 92 insertions(+), 61 deletions(-)

diff --git a/.gradebook.db b/.gradebook.db
index 24f04d0e1f5217aa679ad5883d4fed3e1895787a..095710177373085e56bbaffc2cac368d729f0c51 100644
GIT binary patch
delta 284
zcmZp8z}4`8Yl1Xm%0wAw#*~c-tLpi<xAMvHmhwE}+sduQ6SA>Uh?}{QgMYJbw<aT_
zz~u0rUUnWfUq#<W-pM}m6()1{=CE_K`TBzRg+Tti-X=z_$%=i`82L8u=yMfd<e&U+
zo+nVF$9xq=p2@lMRam)In0*;1tM@6ea)DX<`V@eQ@66x82UOg<E|g6`pG6U<g1c9X
zjmMS67s#B~>%ho8IdZ)*(Cpsz=8SyJN7rvZx}MST1IHQ$?rhFYENeD4&STlWX$jK-
zHclZaPG3P;jtSn|t5-8sFf-?rR!slAj;RF9NMFwssbFein3iZ}nPO~iZk%Y5l45F+
WlALN`o}6NqoNR1nkUII{I|Ts7*jt(a

delta 276
zcmZp8z}4`8Yl1YR(?l6(MyHJltLpjqw(`mGmhwE}3E|$#t+laHh?}{QgJZL9w<aSa
z+vM<`UUpVCUq#<W-pM}m6()1{=CHG{`TBzRg+Tti-X=!o$%=i`7@0Qj=yMfd<e2<#
zo+nVF$9xq=*2%f^RajY6n0*;1tM@6eGJ{$B`V@eQ@66x82UOg<E|iT;pG6U<g1c9X
zjn$RK7s#B~>%hn|IdZ)*(Cpsz=8R0uN7rvZx}MST1IH!??n2HTESokqE@9ceW(m^)
zHclQXPG3P;jtTbLOII^hFi-!mj;UmN`g*2F1v5*t6bs9g6ibUF6C*?OWJ~i@i!_Tg
S%alYzqht$%<jD`;DF6UYZ&$eh

diff --git a/TD.md b/TD.md
index 9cca5e6..32917ef 100644
--- a/TD.md
+++ b/TD.md
@@ -147,7 +147,7 @@ numérique (discrète). Il en existe deux grandes catégories :
 
 % {raw:latex}`\clearpage`
 
-+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "696d89dd98b4217c97e8f8f9da12c80c", "grade": true, "grade_id": "40", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
++++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "541fa69d3773a8dd58dce87cd6cc360e", "grade": true, "grade_id": "40", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
 
 ::::{admonition} Exercice 4 : $\clubsuit$
 
@@ -184,11 +184,11 @@ suivante :
 
 ``` c++
 /** lit une ligne d'un flux et la stocke dans une chaîne de caractères
- *  @param f un flux entrant
+ *  @param flux un flux entrant
  *  @param s une chaîne de caractères
  *  @return le flux entrant
  **/
-istream getline(istream &f, string &s);
+istream getline(istream &flux, string &s);
 ```
 
 % REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE
diff --git a/cours-etat-fichier.md b/cours-etat-fichier.md
index 5ebfb51..2b61684 100644
--- a/cours-etat-fichier.md
+++ b/cours-etat-fichier.md
@@ -27,11 +27,11 @@ rise:
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-# État d'un fichier (ou d'un flux)
+# État d'un flux
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-Jusqu'ici nous avions principalement fait du calcul.  Dans ces
+Jusqu'ici nous avions principalement fait du calcul. Dans ces
 derniers, les situations exceptionnelles sont relativement rares :
 divisions par zéro, préconditions, ...
 
@@ -49,7 +49,7 @@ De ce fait, les opérations peuvent échouer.
 
 Dans cette feuille, nous allons voir comment détecter ces échecs pour
 pouvoir ensuite les gérer. Cela utilisera la notion d'**état d'un
-fichier**.
+flux**.
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -144,18 +144,18 @@ entrées une à une tant que la lecture se passe bien.
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-### État d’un fichier
+### État d’un flux
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
 :::{admonition} Définition
-Une variable de type fichier peut être dans un ***bon état*** :
+Une variable de type flux peut être dans un ***bon état*** :
 
 -   «jusqu’ici tout va bien»
 
 ou un ***mauvais état*** :
 
--   fichier non trouvé à l’ouverture, problème de permissions
+-   fichier non trouvé à l’ouverture ou problème de permissions
 -   lecture ou écriture incorrecte
 -   fin du fichier atteinte
 -   plus de place disque
@@ -166,10 +166,10 @@ ou un ***mauvais état*** :
 
 :::{admonition} Syntaxe
 ``` c++
-        if ( fichier ) { ...
+        if ( flux ) { ...
 ```
 ``` c++
-        if ( fichier >> i ) { ...
+        if ( flux >> i ) { ...
 ```
 :::
 
@@ -250,7 +250,7 @@ annuaire.close();
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-### Bonne pratique : vérifier l’état d’un fichier
+### Bonne pratique : vérifier l’état d’un flux
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
@@ -260,7 +260,7 @@ L'autre inconnue est : le fichier existe-t-il?
 
 :::{hint} Bonne pratique
 
-Toujours vérifier l'état d'un fichier après toute opération pouvant
+Toujours vérifier l'état d'un flux après toute opération pouvant
 échouer, et notamment l'ouverture
 
 :::
@@ -284,7 +284,7 @@ using namespace std;
 slideshow:
   slide_type: fragment
 ---
-ifstream fichier;
+ifstream flux;
 ```
 
 ```{code-cell}
@@ -292,7 +292,7 @@ ifstream fichier;
 slideshow:
   slide_type: fragment
 ---
-fichier.open("annuaire.txt"); // Un fichier existant
+flux.open("annuaire.txt"); // Un fichier existant
 ```
 
 ```{code-cell}
@@ -300,7 +300,7 @@ fichier.open("annuaire.txt"); // Un fichier existant
 slideshow:
   slide_type: fragment
 ---
-if ( not fichier ) {
+if ( not flux ) {
     cout << "Erreur à l'ouverture" << endl;
 }
 ```
@@ -310,7 +310,7 @@ if ( not fichier ) {
 slideshow:
   slide_type: fragment
 ---
-fichier.close();
+flux.close();
 ```
 
 ```{code-cell}
@@ -318,7 +318,7 @@ fichier.close();
 slideshow:
   slide_type: fragment
 ---
-fichier.open("oups.txt");    // Un fichier non existant
+flux.open("oups.txt");    // Un fichier non existant
 ```
 
 ```{code-cell}
@@ -326,17 +326,20 @@ fichier.open("oups.txt");    // Un fichier non existant
 slideshow:
   slide_type: fragment
 ---
-if ( not fichier ) {
+if ( not flux ) {
     cout << "Erreur à l'ouverture" << endl;
 }
 ```
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-:::{hint} Bonne pratique
+:::{admonition} Bonne pratique
+:class: hint
+
 Pour mieux signaler cette situation exceptionnelle, il est recommandé
-d'utiliser les **exceptions**, que nous avons introduites lors du
-[cours précédent](../Semaine7/cours-exceptions.md).
+d'utiliser une **exception** (voir
+[Semaine7](../Semaine7/cours-exceptions.md)).
+
 :::
 
 ```{code-cell}
@@ -352,7 +355,7 @@ slideshow:
 slideshow:
   slide_type: fragment
 ---
-if ( not fichier ) {
+if ( not flux ) {
     throw runtime_error("Erreur à l'ouverture du fichier");
 }
 ```
@@ -361,14 +364,14 @@ if ( not fichier ) {
 
 ## Résumé
 
-Lorsque l'on manipule des fichiers, les opérations sont succeptibles
-d'échouer. Dans cette feuille, nous avons vu que la notion d'**état de
-fichier** permet de détecter de tels échecs pour les traiter. Il est
-fortement recommandé de **systématiquement vérifier l'état du fichier
-après toute opération pouvant échouer**, et tout particulièrement
-après l'ouverture d'un fichier, et de **signaler un tel échec au moyen
-d'une exception**.
+Lorsque l'on manipule des fichiers et des flux, les opérations sont
+susceptibles d'échouer. Dans cette feuille, nous avons vu que la
+notion d'**état de flux** permet de détecter de tels échecs pour les
+traiter. Il est fortement recommandé de **systématiquement vérifier
+l'état du flux après toute opération pouvant échouer**, et tout
+particulièrement après l'ouverture d'un fichier, et de **signaler un
+tel échec au moyen d'une exception**.
 
-La notion d'état d'un fichier peut aussi être mise à profit avec
-l'idiome «lire dans un fichier tant que la lecture se passe bien».
+La notion d'état d'un flux s'utilise naturellement avec l'idiome «lire
+depuis un flux tant que la lecture se passe bien».
 
diff --git a/cours-fichiers.md b/cours-fichiers.md
index 4d40abb..25702dc 100644
--- a/cours-fichiers.md
+++ b/cours-fichiers.md
@@ -77,7 +77,7 @@ slideshow:
   slide_type: fragment
 ---
 // Déclaration
-ofstream  fichier;
+ofstream  flux;
 ```
 
 ```{code-cell}
@@ -86,7 +86,7 @@ slideshow:
   slide_type: fragment
 ---
 // Ouverture
-fichier.open("bla.txt");
+flux.open("bla.txt");
 ```
 
 ```{code-cell}
@@ -95,7 +95,7 @@ slideshow:
   slide_type: fragment
 ---
 // Écriture
-fichier << "Noël " << 42 << endl;
+flux << "Noël " << 42 << endl;
 ```
 
 ```{code-cell}
@@ -104,7 +104,7 @@ slideshow:
   slide_type: fragment
 ---
 // Fermeture
-fichier.close();
+flux.close();
 ```
 
 +++ {"slideshow": {"slide_type": "slide"}}
@@ -113,7 +113,7 @@ fichier.close();
 
 Écrire dans un fichier se fait  en **quatre étapes** :
 
-1.  Déclaration
+1.  Déclaration du flux
 2.  Ouverture du fichier
 3.  Écriture
 4.  Fermeture du fichier
@@ -143,7 +143,7 @@ slideshow:
   slide_type: fragment
 ---
 // Déclaration
-ifstream fichier;
+ifstream flux;
 ```
 
 ```{code-cell}
@@ -152,7 +152,7 @@ slideshow:
   slide_type: fragment
 ---
 // Ouverture du fichier
-fichier.open("bla.txt");
+flux.open("bla.txt");
 ```
 
 ```{code-cell}
@@ -162,7 +162,7 @@ slideshow:
 ---
 string s;
 // Lecture
-fichier >> s;
+flux >> s;
 s
 ```
 
@@ -172,7 +172,7 @@ slideshow:
   slide_type: fragment
 ---
 int i;
-fichier >> i;
+flux >> i;
 i
 ```
 
@@ -182,20 +182,47 @@ slideshow:
   slide_type: fragment
 ---
 // Fermeture du fichier
-fichier.close();
+flux.close();
 ```
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
 :::{admonition} À retenir
+:class: hint
 
 De même que l'écriture dans un fichier, la lecture se fait en **quatre
 étapes** :
 
-1.  Déclaration
+1.  Déclaration du flux
 2.  Ouverture du fichier
 3.  Lecture
 4.  Fermeture du fichier
 
 :::
 
++++ {"slideshow": {"slide_type": "slide"}}
+
+:::{admonition} À retenir
+:class: hint
+
+- La lecture et l'écriture se fait en fonction du type des données.
+- À la lecture, les espaces, tabulations et sauts de lignes servent de
+  séparateurs entre entiers, mots, etc.
+
+:::
+
++++ {"slideshow": {"slide_type": "fragment"}}
+
+:::{admonition} À retenir
+:class: hint
+
+Comme nous utilisons un flux pour lire depuis un fichier, la lecture
+se fait de façon séquentielle depuis le début du fichier. De même pour
+l'écriture, il est nécessaire de réécrire l'intégralité du fichier.
+
+Il existe d'autres façons d'accéder à un fichier permettant de n'en
+lire ou n'en modifier qu'une fraction -- on parler d'accès aléatoire
+(*random access*) -- mais nous n'en aurons pas besoin ce semestre.
+
+:::
+
diff --git a/cours-flux-chaines-de-caracteres.md b/cours-flux-chaines-de-caracteres.md
index 1f6290b..dd2c1a2 100644
--- a/cours-flux-chaines-de-caracteres.md
+++ b/cours-flux-chaines-de-caracteres.md
@@ -81,9 +81,8 @@ Comment extraire ces nombres de `s`?
 +++ {"slideshow": {"slide_type": "notes"}}
 
 On souhaiterait extraire ces nombres en les convertissant en entiers.
-Pour cela on créé un *flux* de type `istringstream` (nous verrons dans
-la feuille suivante ce qu'est un flux et la signification du nom
-`istringstream`) :
+Pour cela on créé un *flux* de type `istringstream` (pour flux entrant
+depuis une chaîne de caractères) rattaché à `s` :
 
 ```{code-cell}
 ---
@@ -150,14 +149,15 @@ i
 +++ {"slideshow": {"slide_type": "slide"}}
 
 L'exemple suivant illustre que l'on peut lire successivement des
-valeurs de types mixtes, et que l'on peut chaîner ces lectures :
+valeurs de types mixtes, qu'un nombre quelconque d'espaces sert de
+séparateur, et que l'on peut enchaîner ces lectures :
 
 ```{code-cell}
 ---
 slideshow:
   slide_type: fragment
 ---
-string s = "truc 33 bidule 2.5 reste"
+string s = "truc 33   bidule   2.5 reste"
 ```
 
 ```{code-cell}
@@ -258,9 +258,8 @@ caractères. Le principe sera le même que pour une lecture.
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-On commence par définir un flux de type `ostringstream` (là encore,
-nous verrons dans la feuille suivante la signification du nom de ce
-type) :
+On commence par définir un flux de type `ostringstream` (pour flux
+sortant vers une chaîne de caractères) :
 
 ```{code-cell}
 ---
@@ -464,9 +463,11 @@ CHECK( formateEntreeAnnuaire("Lovelace", "Ada", "07 23 23 23 23")
 ## Résumé
 
 Dans cette feuille:
-- nous avons vu comment **lire et écrire** des données de types divers **dans des chaînes de caractères**.
-- Nous l'avons appliqué pour mieux séparer **fonctions qui calculent** et **fonctions d'entrées-sorties**.
-- Enfin nous avons noté que l'on utilise la même syntaxe que pour lire et écrire dans un fichier ou
-  pour interagir avec l'utilisateur.  
-  Cela est rendu possible par le concept de flux qui est le sujet de la [feuille suivante](cours-flux.md).
+- nous avons vu comment **lire et écrire** des données de types divers
+  **dans des chaînes de caractères**.
+- Nous l'avons appliqué pour mieux séparer **fonctions qui calculent**
+  et **fonctions d'entrées-sorties**.
+- Enfin nous avons noté que, grâce au concept de flux, on peut
+  utiliser la même syntaxe que pour lire et écrire dans un fichier ou
+  pour interagir avec l'utilisateur.
 
diff --git a/cours-flux.md b/cours-flux.md
index 5bd9518..5910aea 100644
--- a/cours-flux.md
+++ b/cours-flux.md
@@ -27,11 +27,11 @@ rise:
 
 +++ {"slideshow": {"slide_type": "note"}}
 
-Avant de voir comment lire et écrire dans un fichier, nous avions vu
-comment afficher; c'est-à-dire écrire à l'écran au moyen de
-`cout`. Nous avons occasionnellement vu comment lire depuis le clavier
-`cin`. Nous allons maintenant formaliser cela et introduire la notion
-de flux.
+Les semaines précédentes, nous avons vu comment afficher; c'est-à-dire
+écrire à l'écran au moyen de `cout`. Nous avons occasionnellement vu
+comment lire depuis le clavier avec `cin`. Nous allons maintenant
+formaliser cela et introduire la notion de flux qui nous servira
+ensuite pour lire et écrire dans des fichiers.
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-- 
GitLab