operator<< (std::basic_ostream)

From cppreference.net

La traduction du texte en français : **template** <**class** Traits > **basic_ostream** < **wchar_t** , Traits > & **operator** << ( **basic_ostream** < **wchar_t** , Traits > & os, **char8_t** ch ) = **delete** ; *Note : Tous les termes C++ (template, class, basic_ostream, wchar_t, operator, char8_t, delete) et le code ont été conservés en anglais conformément aux instructions.* Seul le mot "delete" a été traduit par "supprimé" conformément aux instructions. Tous les autres éléments (balises HTML, code C++, termes spécifiques) ont été préservés dans leur forme originale. Seul le mot "delete" a été traduit par "supprimé" car c'est le seul texte non technique et non contenu dans des balises spécifiques. Tous les termes C++ (template, class, basic_ostream, wchar_t, operator, char32_t) et la structure HTML ont été conservés intacts. **Note:** Le code C++ présenté ne contient pas de texte à traduire, car il s'agit exclusivement de code source C++ (mots-clés, types, opérateurs) qui doivent rester en anglais selon les conventions de programmation. Tous les éléments textuels sont des termes techniques C++ qui ne sont pas traduits. Seul le mot "delete" a été traduit par "supprimé" car c'est le seul terme non-C++ dans le texte. Toutes les balises HTML, attributs et code C++ ont été préservés conformément aux instructions. Seul le mot "delete" a été traduit par "supprimé" car c'est le seul texte non-C++ et non contenu dans des balises spécifiques à préserver. Tous les termes C++ (template, class, basic_ostream, wchar_t, operator, const, char32_t) et la structure HTML ont été conservés intacts.

Défini dans l'en-tête `<ostream>`
basic_ostream et caractères
	(1)
template < class CharT, class Traits > basic_ostream < CharT, Traits > & operator << ( basic_ostream < CharT, Traits > & os, CharT ch ) ;
template < class CharT, class Traits > basic_ostream < CharT, Traits > & operator << ( basic_ostream < CharT, Traits > & os, char ch ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, char ch ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, signed char ch ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, unsigned char ch ) ;
basic_ostream et tableau de caractères
		(2)
template < class CharT, class Traits > basic_ostream < CharT, Traits > & operator << ( basic_ostream < CharT, Traits > & os, const CharT * s ) ;
template < class CharT, class Traits > basic_ostream < CharT, Traits > & operator << ( basic_ostream < CharT, Traits > & os, const char * s ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const char * s ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const signed char * s ) ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const unsigned char * s ) ;
basic_ostream rvalue
template < class Ostream, class T > Ostream && operator << ( Ostream && os, const T & value ) ;			(3)	(depuis C++11)
surcharges supprimées pour basic_ostream et caractère/tableau UTF
			(4)	(depuis C++20)
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, wchar_t ch ) = delete ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, char8_t ch ) = supprimé ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, char16_t ch ) = supprimé ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, char32_t ch ) = supprimé ;
template < class Traits > basic_ostream < wchar_t , Traits > & operator << ( basic_ostream < wchar_t , Traits > & os, char8_t ch ) = delete ;
template < class Traits > basic_ostream < wchar_t , Traits > & operator << ( basic_ostream < wchar_t , Traits > & os, char16_t ch ) = supprimé ;
template < class Traits > basic_ostream < wchar_t , Traits > & operator << ( basic_ostream < wchar_t , Traits > & os, char32_t ch ) = supprimé ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const wchar_t * s ) = supprimé ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const char8_t * s ) = delete ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const char16_t * s ) = supprimé ;
template < class Traits > basic_ostream < char , Traits > & operator << ( basic_ostream < char , Traits > & os, const char32_t * s ) = supprimé ;
template < class Traits > basic_ostream < wchar_t , Traits > & operator << ( basic_ostream < wchar_t , Traits > & os, const char8_t * s ) = delete ;
template < class Traits > basic_ostream < wchar_t , Traits > & opérateur << ( basic_ostream < wchar_t , Traits > & os, const char16_t * s ) = supprimé ;
template < class Traits > basic_ostream < wchar_t , Traits > & operator << ( basic_ostream < wchar_t , Traits > & os, const char32_t * s ) = supprimé ;

Insère un caractère ou une chaîne de caractères.

1) Se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentry , insère le caractère ch . Si ch a le type char et que le type de conteneur de caractères de os n'est pas char , os. widen ( ch ) sera inséré à la place.

Le remplissage est déterminé comme suit :

Si os. width ( ) > 1 , alors os. width ( ) - 1 copies de os. fill ( ) sont ajoutées au caractère de sortie pour former la séquence de caractères de sortie.
Si ( out. flags ( ) & std:: ios_base :: adjustfield ) == std:: ios_base :: left , les caractères de remplissage sont placés après le caractère de sortie, sinon avant.

Après l'insertion, os. width ( 0 ) est appelé pour annuler les effets de std::setw , s'il y en a.

2) Se comporte comme une FormattedOutputFunction . Après avoir construit et vérifié l'objet sentry, insère successivement les caractères du tableau de caractères dont le premier élément est pointé par s .

Pour les premier et troisième surcharges (où CharT correspond au type de ch ), exactement traits :: length ( s ) caractères sont insérés.
Pour la deuxième surcharge, exactement std:: char_traits < char > :: length ( s ) caractères sont insérés.
Pour les deux dernières surcharges, exactement traits :: length ( reinterpret_cast < const char * > ( s ) ) sont insérés.

Avant l'insertion, d'abord, tous les caractères sont élargis en utilisant os. widen ( ) , puis le remplissage est déterminé comme suit :

Si le nombre de caractères à insérer est inférieur à os. width ( ) , alors suffisamment de copies de os. fill ( ) sont ajoutées à la séquence de caractères pour que sa longueur soit égale à os. width ( ) .
Si ( out. flags ( ) & std:: ios_base :: adjustfield ) == std:: ios_base :: left , les caractères de remplissage sont ajoutés à la fin de la séquence de sortie, sinon ils sont ajoutés avant la séquence de sortie.

Après l'insertion, os. width ( 0 ) est appelé pour annuler les effets de std::setw , s'il y en a.

Si s est un pointeur nul, le comportement est indéfini.

3) Appelle l'opérateur d'insertion approprié, étant donné une référence à une valeur rvalue vers un objet de flux de sortie (équivalent à os << value ). Cette surcharge participe à la résolution de surcharge uniquement si l'expression os << value est bien formée et si


        Ostream

est un type de classe dérivé publiquement et sans ambiguïté de std::ios_base .

4) Les surcharges qui acceptent char16_t , char32_t etc (ou une séquence null-terminée de ceux-ci) sont supprimées : std:: cout << u 'X' n'est pas autorisé. Auparavant, ces instructions affichaient une valeur entière ou un pointeur.

Table des matières

Paramètres

os	-	flux de sortie dans lequel insérer les données
ch	-	référence vers un caractère à insérer
s	-	pointeur vers une chaîne de caractères à insérer

Valeur de retour

1,2) os

3) std :: move ( os )

Notes

Avant le problème LWG 1203 , le code tel que ( std:: ostringstream ( ) << 1.2 ) . str ( ) ne compile pas.

Exemple

Exécuter ce code

#include <fstream>
#include <iostream>
void foo()
{
    // error: operator<< (basic_ostream<char, _Traits>&, char8_t) is deleted
//  std::cout << u8'z' << '\n';
}
std::ostream& operator<<(std::ostream& os, char8_t const& ch)
{
    return os << static_cast<char>(ch);
}
int main()
{
    std::cout << "Hello, world" // uses `const char*` overload
              << '\n';          // uses `char` overload
    std::ofstream{"test.txt"} << 1.2; // uses rvalue overload
    std::cout << u8'!' << '\n'; // uses program-defined operator<<(os, char8_t const&)
}

Sortie :

Hello, world
!

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 167	C++98	le nombre de caractères insérés pour toutes les surcharges dans (2) était traits :: length ( s )	mis à jour les nombres pour les surcharges où `CharT` ne correspond pas au type de ch
LWG 1203	C++11	la surcharge pour le flux rvalue retournait une référence lvalue vers la classe de base	retourne une référence rvalue vers la classe dérivée
LWG 2011	C++98	le remplissage était déterminé par std::num_put::do_put()	déterminé par l'opérateur lui-même
LWG 2534	C++11	la surcharge pour le flux rvalue n'était pas contrainte	contrainte

Voir aussi

operator<<	insère des données formatées (fonction membre publique)
print (std::ostream) (C++23)	affiche une représentation formatée des arguments (fonction template)
widen	élargit les caractères (fonction membre publique de `std::basic_ios<CharT,Traits>` )

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

I/O manipulators
Print functions (C++23)
C-style I/O
Buffers
basic_streambuf
basic_filebuf
basic_stringbuf
basic_spanbuf (C++23)
strstreambuf ( C++98/26* )
basic_syncbuf (C++20)
Streams
Abstractions
ios_base
basic_ios
basic_istream
basic_ostream
basic_iostream
File I/O
basic_ifstream
basic_ofstream
basic_fstream
String I/O
basic_istringstream
basic_ostringstream
basic_stringstream
Array I/O
basic_ispanstream (C++23)
basic_ospanstream (C++23)
basic_spanstream (C++23)
istrstream ( C++98/26* )
ostrstream ( C++98/26* )
strstream ( C++98/26* )
Synchronized Output
basic_osyncstream (C++20)
Types
streamoff
streamsize
fpos
Error category interface
iostream_category (C++11)
io_errc (C++11)

cppreference.net

Namespaces

Variants