Namespaces
Variants

std::basic_ostream<CharT,Traits>:: operator<<

From cppreference.net
C++
Input/output library
std::basic_ostream
basic_ostream & operator << ( bool value ) ;
(1)
basic_ostream & operator << ( long value ) ;
(2)
basic_ostream & operator << ( unsigned long value ) ;
(3)
basic_ostream & operator << ( long long value ) ;
(4) (depuis C++11)
basic_ostream & operator << ( unsigned long long value ) ;
(5) (depuis C++11)
basic_ostream & operator << ( double value ) ;
(6)
basic_ostream & operator << ( long double value ) ;
(7)
basic_ostream & operator << ( const void * value ) ;
(8)
basic_ostream & operator << ( const volatile void * value ) ;
(9) (depuis C++23)
basic_ostream & operator << ( std:: nullptr_t ) ;
(10) (depuis C++17)
basic_ostream & operator << ( short value ) ;
(11)
basic_ostream & operator << ( int value ) ;
(12)
basic_ostream & operator << ( unsigned short value ) ;
(13)
basic_ostream & operator << ( unsigned int valeur ) ;
(14)
basic_ostream & operator << ( float valeur ) ;
(15)
basic_ostream & operator << ( /* extended-floating-point-type */ value ) ;
(16) (depuis C++23)
basic_ostream & operator << ( std:: basic_streambuf < CharT, Traits > * sb ) ;
(17)
basic_ostream & operator << (
std:: ios_base & ( * func ) ( std:: ios_base & ) ) ;
(18)
basic_ostream & operator << (
std:: basic_ios < CharT, Traits > & ( * func ) ( std:: basic_ios < CharT, Traits > & ) ) ;
(19)
basic_ostream & operator << (

std:: basic_ostream < CharT, Traits > & ( * func )

( std:: basic_ostream < CharT, Traits > & ) ) ;
(20)

Insère des données dans le flux.

1-8) Insère value .
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentry, elle insère une valeur en appelant std::num_put::put() . Si la condition de fin de fichier a été rencontrée durant la sortie ( put ( ) . failed ( ) == true ), elle positionne le badbit .
9) Équivalent à return operator << ( const_cast < const void * > ( p ) ) ; .
10) Équivalent à return * this << s ; , où s est une chaîne de caractères de type implémentation-définie terminée par un caractère nul.
11) Insère une valeur de short value .
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentinelle, elle insère une valeur long lval comme dans (2) , où lval est
12) Insère une valeur de type int value .
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentinelle, elle insère une valeur long lval comme dans (2) , où lval est
13,14) Insère une valeur depuis unsigned short ou unsigned int value .
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentinelle, insère static_cast < unsigned long > ( value ) comme dans (3) .
15) Insère une valeur de type float value .
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentinelle, elle insère static_cast < double > ( value ) comme dans (6) .
16) Insère une valeur à partir de value . La bibliothèque fournit des surcharges pour tous les extended floating-point types sans qualificatif cv comme type du paramètre value.
Cette fonction se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentry, vérifie le rang de conversion en virgule flottante de /* extended-floating-point-type */ :
  • Si le rang est inférieur ou égal à celui de double , insère static_cast < double > ( value ) comme dans (6) .
  • Sinon, si le rang est inférieur ou égal à celui de long double , insère static_cast < long double > ( value ) comme dans (7) .
  • Sinon, un appel de cette surcharge est conditionnellement pris en charge avec une sémantique définie par l'implémentation.
17) Cette fonction se comporte comme une UnformattedOutputFunction . Après avoir construit et vérifié l'objet sentry, vérifie si sb est un pointeur nul. Si c'est le cas, exécute setstate ( badbit ) et se termine. Sinon, extrait les caractères de la séquence d'entrée contrôlée par sb et les insère dans * this jusqu'à ce que l'une des conditions suivantes soit remplie :
  • la fin de fichier se produit sur la séquence d'entrée ;
  • l'insertion dans la séquence de sortie échoue (auquel cas le caractère à insérer n'est pas extrait) ;
  • une exception se produit (auquel cas l'exception est capturée).
Si aucun caractère n'a été inséré, exécute setstate ( failbit ) . Si une exception a été levée lors de l'extraction, définit failbit et, si failbit est défini dans exceptions() , relance l'exception.
18-20) Appelle func ( * this ) . Ces surcharges sont utilisées pour implémenter les manipulateurs de sortie E/S tels que std::endl .

Table des matières

Paramètres

value - valeur entière, à virgule flottante, booléenne ou pointeur à insérer
func - fonction à appeler
sb - pointeur vers le tampon de flux pour lire les données

Valeur de retour

1-19) * this
20) func ( * this )

Notes

Il n'y a pas de surcharges pour les pointeurs vers les membres non statiques , les pointeurs vers volatiles, (jusqu'à C++23) ou les pointeurs de fonctions (à l'exception de ceux dont les signatures sont acceptées par les ( 18-20 ) surcharges).

  • Tenter d'afficher de tels objets invoque une conversion implicite en bool , et, pour toute valeur de pointeur non nulle, la valeur 1 est imprimée (sauf si boolalpha était activé, auquel cas true est imprimé).

Les arguments de type caractère et chaîne de caractères (par exemple, de type char ou const char * ) sont traités par les surcharges non-membres de operator << .

  • Tenter d'afficher un caractère en utilisant la syntaxe d'appel de fonction membre (par exemple, std:: cout . operator << ( 'c' ) ; ) appellera l'une des surcharges dans ( 2-5 ) ou ( 11-14 ) et affichera la valeur numérique.
  • Tenter d'afficher une chaîne de caractères en utilisant la syntaxe d'appel de fonction membre appellera la surcharge (8) et affichera la valeur du pointeur à la place.

La surcharge (10) a été ajoutée par la résolution de LWG issue 2221 , mais elle n'est jamais implémentée dans aucune implémentation de bibliothèque standard en modes C++11/14.

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <sstream>
int fun() { return 42; }
int main()
{
    std::istringstream input(" \"Some text.\" ");
    double f = 3.14;
    bool b = true;
    std::cout
        << fun()          // surcharge int (12)
        << ' '            // surcharge non-membre
        << std::boolalpha // surcharge fonction (18)
        << b              // surcharge bool (1)
        << " "            // surcharge non-membre
        << std::fixed     // surcharge fonction (18) à nouveau
        << f              // surcharge double (6)
        << input.rdbuf()  // surcharge streambuf
        << fun            // surcharge bool (1) : il n'y a pas de surcharge pour int(*)()
        << std::endl;     // surcharge fonction (18) à nouveau
    int x = 0;
    int* p1 = &x;
    volatile int* p2 = &x;
    std::cout
        << "p1: " << p1 << '\n'  // surcharge `const void*`, affiche l'adresse
        << "p2: " << p2 << '\n'; // avant C++23 (P1147) : surcharge bool :), car
            // operator<<(const void*) ne correspond pas car il supprime le qualificateur `volatile`
            // Pour corriger cela, C++23 ajoute la surcharge `const volatile void*` (9),
            // qui affiche l'adresse comme attendu.
}

Sortie possible : 

42 true 3.140000 "Some text." true
p1: 0x7ffcea766600
p2: 0x7ffcea766600

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 117 C++98 les surcharges (1-8,11-15) déléguaient l'insertion à
num_put::put , mais il n'a pas de surcharges pour short ,
unsigned short , int , unsigned int , et float 		ils sont convertis
avant d'être passés
à num_put::put
LWG 567 C++98 la surcharge (17) se comportait comme une FormattedOutputFunction
en raison de la résolution de LWG issue 60 		elle se comporte comme une
UnformattedOutputFunction

Voir aussi

insère des données de caractères ou insère dans un flux de rvalue
(fonction template)
effectue l'entrée et la sortie de flux sur les chaînes
(fonction template)
(C++17)
effectue la sortie de flux sur les vues de chaînes
(fonction template)
effectue l'entrée et la sortie de flux des bitsets
(fonction template)
sérialise et désérialise un nombre complexe
(fonction template)
(C++11)
effectue l'entrée et la sortie de flux sur un moteur de nombres pseudo-aléatoires
(fonction template)
(C++11)
effectue l'entrée et la sortie de flux sur une distribution de nombres pseudo-aléatoires
(fonction template)
insère un caractère
(fonction membre publique)
insère des blocs de caractères
(fonction membre publique)
(C++17)
convertit une valeur entière ou à virgule flottante en une séquence de caractères
(fonction)