std:: endl
|
Défini dans l'en-tête
<ostream>
|
||
|
template
<
class
CharT,
class
Traits
>
std:: basic_ostream < CharT, Traits > & endl ( std:: basic_ostream < CharT, Traits > & os ) ; |
||
Insère un caractère de nouvelle ligne dans la séquence de sortie os et la vide comme en appelant os. put ( os. widen ( ' \n ' ) ) suivi de os. flush ( ) .
Ceci est un manipulateur d'E/S en sortie uniquement, il peut être appelé avec une expression telle que
out
<<
std
::
endl
pour tout
out
de type
std::basic_ostream
.
Table des matières |
Notes
Ce manipulateur peut être utilisé pour produire immédiatement une ligne de sortie, par exemple lors de l'affichage de la sortie d'un processus de longue durée, de la journalisation de l'activité de multiples threads ou de la journalisation de l'activité d'un programme susceptible de planter de manière inattendue. Un vidage explicite de
std::cout
est également nécessaire avant un appel à
std::system
, si le processus créé effectue toute opération d'E/S d'écran. Dans la plupart des autres scénarios d'E/S interactives habituelles,
std::endl
est redondant lorsqu'il est utilisé avec
std::cout
car toute entrée depuis
std::cin
, sortie vers
std::cerr
, ou terminaison du programme force un appel à
std::
cout
.
flush
(
)
. L'utilisation de
std::endl
à la place de
'
\n
'
, encouragée par certaines sources, peut considérablement dégrader les performances de sortie.
Dans de nombreuses implémentations, la sortie standard est tamponnée par ligne, et l'écriture de
'
\n
'
provoque de toute façon un vidage, sauf si
std
::
ios
::
sync_with_stdio
(
false
)
a été exécuté. Dans ces situations, l'utilisation inutile de
endl
ne fait que dégrader les performances de la sortie fichier, et non celles de la sortie standard.
Les exemples de code sur ce wiki suivent Bjarne Stroustrup et The C++ Core Guidelines en vidant la sortie standard uniquement lorsque nécessaire.
Lorsqu'une ligne de sortie incomplète doit être vidée, le std::flush manipulateur peut être utilisé.
Lorsque chaque caractère de sortie doit être vidé, le std::unitbuf manipulateur peut être utilisé.
Paramètres
| os | - | référence au flux de sortie |
Valeur de retour
os (référence au flux après manipulation).
Exemple
Avec
'
\n
'
au lieu de
endl
, la sortie serait la même, mais pourrait ne pas apparaître en temps réel.
#include <chrono> #include <iostream> template<typename Diff> void log_progress(Diff d) { std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d) << " passed" << std::endl; } int main() { std::cout.sync_with_stdio(false); // on some platforms, stdout flushes on \n static volatile int sink{}; const auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < 5; ++i) { for (int j = 0; j < 10000; ++j) for (int k = 0; k < 20000; ++k) sink += i * j * k; // do some work log_progress(std::chrono::high_resolution_clock::now() - t1); } }
Sortie possible :
566ms passed 1133ms passed 1699ms passed 2262ms passed 2829ms passed
Voir aussi
|
contrôle si la sortie est vidée après chaque opération
(fonction) |
|
|
vide le flux de sortie
(modèle de fonction) |
|
|
se synchronise avec le dispositif de stockage sous-jacent
(fonction membre publique de
std::basic_ostream<CharT,Traits>
)
|