Newer
Older
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
rise:
auto_select: first
autolaunch: false
centered: false
controls: false
enable_chalkboard: true
height: 100%
margin: 0
maxScale: 1
minScale: 1
scroll: true
slideNumber: true
start_slideshow_at: selected
transition: none
width: 90%
---
+++ {"slideshow": {"slide_type": "note"}}
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"}}
# Notion de flux de données
+++ {"slideshow": {"slide_type": "fragment"}}
::::{admonition} Définition
Un ***flux sortant*** est un dispositif où l’on peut écrire
des données, successivement *l’une après l’autre*.
:::{admonition} Syntaxe
```
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
```
:::
:::{admonition} Sémantique
Écrit la valeur de l'expression dans le flux. La valeur est convertie
en texte en fonction de son type.
:::
% +++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Remarque
:class: hint
On peut enchaîner l'écriture successive de plusieurs expressions :
```
flux << expression1 << expression2 << expression3;
```
:::
::::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Exemples de flux sortants
- `cout` : ***sortie standard*** du programme
Typiquement : écran
♣ Avec tampon
- `cerr` : ***sortie d’erreur*** du programme
♣ Sans tampon
:::
```{code-cell}
---
slideshow:
slide_type: fragment
---
#include <iostream>
using namespace std;
cout << "Noël " << 42 << endl;
```
+++ {"slideshow": {"slide_type": "slide"}}
::::{admonition} Définition
Un ***flux entrant*** est un dispositif où l’on peut lire des
données, successivement *l’une après l’autre*.
:::{admonition} Syntaxe
```
flux >> variable;
```
:::
:::{admonition} Sémantique
Lit une valeur depuis le flux et l'affecte à la variable. Le type de
la variable est utilisé pour déterminer comment lire la variable.
:::
% +++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Remarque
:class: hint
On peut enchaîner la lecture successive de plusieurs variables :
```
flux >> variable1 >> variable2 >> variable3;
```
:::
::::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Exemple de flux entrant
- `cin` : ***entrée standard*** du programme
Typiquement : clavier
:::
```{code-cell}
---
slideshow:
slide_type: fragment
---
string nom;
cout << "Comment t'appelles-tu?" << endl;
cin >> nom;
nom
```
+++ {"slideshow": {"slide_type": "slide"}}
:::{admonition} Astuce mnémotechnique
:class: hint
Le sens des chevrons met en valeur dans quel sens se déplacent les
informations :
- `flux << expression` : de l'expression vers le flux;
- `flux >> variable` : du flux vers la variable.
:::
+++ {"slideshow": {"slide_type": "slide"}}
:::{admonition} Astuce mnémotechnique
:class: hint
En anglais, «flux» se dit «*stream*», «entrée» «*input*» et «sortie»
«*output*».
D'où le nom de la bibliothèque `iostream` qui définit le flux
(*stream*) entrant (*i*) `cin` et les flux sortants (*o*) `cout` et
`cerr`.
:::