Namespaces
Variants

std::basic_stringbuf<CharT,Traits,Allocator>:: basic_stringbuf

From cppreference.net
C++
Input/output library
std::basic_stringbuf
Les modifications apportées : - "which" a été traduit par "mode" (plus approprié dans ce contexte C++) - "since" a été traduit par "depuis" - Tous les tags HTML, attributs et contenu des balises ` ` ont été préservés - Les termes spécifiques C++ (basic_stringbuf, StringViewLike, std::ios_base, etc.) n'ont pas été traduits
(1)
(jusqu'en C++11)
explicit basic_stringbuf ( std:: ios_base :: openmode which ) ;
(depuis C++11)
basic_stringbuf ( )
: basic_stringbuf ( std:: ios_base :: in | std:: ios_base :: out ) { }
(2) (depuis C++11)
explicit

basic_stringbuf ( const std:: basic_string < CharT, Traits, Allocator > & s,
std:: ios_base :: openmode which =

std:: ios_base :: in | std:: ios_base :: out ) ;
(3)
explicit basic_stringbuf ( std:: basic_string < CharT, Traits, Allocator > && s,

std:: ios_base :: openmode mode =

std:: ios_base :: in | std:: ios_base :: out ) ;
(4) (depuis C++20)
basic_stringbuf ( std:: ios_base :: openmode which, const Allocator & a ) ;
(5) (depuis C++20)
explicit basic_stringbuf ( const Allocator & a )
: basic_stringbuf ( std:: ios_base :: in | std:: ios_base :: out , a ) { }
(6) (depuis C++20)
template < class SAlloc >

explicit basic_stringbuf ( const std:: basic_string < CharT, Traits, SAlloc > & s,
std:: ios_base :: openmode which =

std:: ios_base :: in | std:: ios_base :: out ) ;
(7) (depuis C++20)
template < class SAlloc >

basic_stringbuf ( const std:: basic_string < CharT, Traits, SAlloc > & s,

std:: ios_base :: openmode mode, const Allocator & a ) ;
(8) (depuis C++20)
template < class SAlloc >

basic_stringbuf ( const std:: basic_string < CharT, Traits, SAlloc > & s,
const Allocator & a )

: basic_stringbuf ( s, std:: ios_base :: in | std:: ios_base :: out , a ) { }
(9) (depuis C++20)
template < class StringViewLike >

explicit basic_stringbuf ( const StringViewLike & t,
std:: ios_base :: openmode mode =

std:: ios_base :: in | std:: ios_base :: out ) ;
(10) (depuis C++26)
template < class StringViewLike >

basic_stringbuf ( const StringViewLike & t,

std:: ios_base :: openmode which, const Allocator & a ) ;
(11) (depuis C++26)
template < class StringViewLike >
basic_stringbuf ( const StringViewLike & t, const Allocator & a ) ;
(12) (depuis C++26)
basic_stringbuf ( basic_stringbuf && rhs ) ;
(13) (depuis C++11)
basic_stringbuf ( basic_stringbuf && rhs, const Allocator & a ) ;
(14) (depuis C++20)
basic_stringbuf ( const basic_stringbuf & rhs ) = delete ;
(15) (depuis C++11)

La base std::basic_streambuf et les membres de données exposition-only buf et mode sont initialisés comme suit.

Après l'initialisation de ces sous-objets, les surcharges (3-12) initialisent les séquences d'entrée et de sortie comme si elles appelaient init_buf_ptrs () .

Surcharge std::basic_streambuf base buf mode
(1) initialisé par défaut défini par l'implémentation
(voir ci-dessous) 		which
(2) std:: ios_base :: in |
std:: ios_base :: out
(3) s which
(4) std :: move ( s )
(5) a
(6) std:: ios_base :: in |
std:: ios_base :: out
(7) s which
(8) { s, a }
(9) std:: ios_base :: in |
std:: ios_base :: out
(10) { sv, Allocator ( ) } which
(11) { sv, a }
(12) std:: ios_base :: in |
std:: ios_base :: out
(13) rhs
(copie construite) 		std :: move ( rhs ) . str ( ) rhs. mode
(14) { std :: move ( rhs ) . str ( ) , a }
1,2) Surcharge (1) (jusqu'à C++11) (2) (depuis C++11) est le constructeur par défaut. Il est défini par l'implémentation si les pointeurs de séquence ( eback() , gptr() , egptr() , pbase() , pptr() , epptr() ) sont initialisés à des pointeurs nuls.
5,6) Lorsque la construction est terminée, str. empty ( ) est true .
7) Cette surcharge participe à la résolution de surcharge uniquement si std:: is_same_v < SAlloc, Allocator > est false .
10-12) Convertit implicitement t en une vue de chaîne sv comme si par std:: basic_string_view < CharT, Traits > sv = t ; , puis elle est utilisée comme ci-dessus dans le tableau.
Ces surcharges participent à la résolution de surcharge seulement si std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >> est true .
13,14) La surcharge (13) est le constructeur de déplacement. Il est défini par l'implémentation si les six pointeurs de séquence dans * this obtiennent les valeurs que rhs possédait.
When the construction is complete, rhs is empty but usable, and
  • Soit rhs_p l'état de rhs juste avant cette construction, les expressions suivantes évalueront à true :
  • str ( ) == rhs_p. str ( )
  • getloc ( ) == rhs_p. getloc ( )
  • gptr ( ) - eback ( ) == rhs_p. gptr ( ) - rhs_p. eback ( )
  • egptr ( ) - eback ( ) == rhs_p. egptr ( ) - rhs_p. eback ( )
  • pptr ( ) - pbase ( ) == rhs_p. pptr ( ) - rhs_p. pbase ( )
  • epptr ( ) - pbase ( ) == rhs_p. epptr ( ) - rhs_p. pbase ( )
*Note: Le contenu étant entièrement composé de code C++ dans des balises ` `, aucun texte n'a nécessité de traduction selon vos instructions.*
  • Soit rhs_a l'état de rhs juste après cette construction, les expressions suivantes évalueront à true :
  • ! eback ( ) || eback ( ) ! = rhs_a. eback ( )
  • ! gptr ( ) || gptr ( ) ! = rhs_a. gptr ( )
  • ! egptr ( ) || egptr ( ) ! = rhs_a. egptr ( )
  • ! pbase ( ) || pbase ( ) ! = rhs_a. pbase ( )
  • ! pptr ( ) || pptr ( ) ! = rhs_a. pptr ( )
  • ! epptr ( ) || epptr ( ) ! = rhs_a. epptr ( )
**Note:** Le contenu étant entièrement composé de code C++ (balises ` `), aucun texte n'a nécessité de traduction conformément aux instructions. La structure HTML et les termes spécifiques au C++ ont été préservés.
15) Le constructeur de copie est supprimé ; std::basic_stringbuf n'est pas CopyConstructible .

Table des matières

Paramètres

s - une std::basic_string utilisée pour initialiser le tampon
t - un objet (convertible en std::basic_string_view ) utilisé pour initialiser le tampon
a - un autre allocateur utilisé pour construire la std::basic_string interne
rhs - un autre basic_stringbuf
which - spécifie le mode d'ouverture du flux. C'est un type masque de bits, les constantes suivantes sont définies :
Constante Explication
app se positionner en fin de flux avant chaque écriture
binary ouvrir en mode binaire
in ouvrir en lecture
out ouvrir en écriture
trunc vider le contenu du flux à l'ouverture
ate se positionner en fin de flux immédiatement après l'ouverture
noreplace (C++23) ouvrir en mode exclusif

Notes

Généralement appelé par le constructeur de std::basic_stringstream .

Le niveau de support pour les modes d'ouverture autres que std::ios_base::in et std::ios_base::out varie selon les implémentations. C++11 spécifie explicitement le support pour std::ios_base::ate dans str() et dans ce constructeur, mais std::ios_base::app , std::ios_base::trunc , et std::ios_base::binary ont des effets différents selon les implémentations.

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_sstream_from_string_view 202306L (C++26) Interface des flux de chaînes avec std::string_view

Exemple

Démontre l'appel direct du constructeur de std::basic_stringbuf :

Exécuter ce code 
#include <iostream>
#include <sstream>
int main()
{
    // constructeur par défaut (mode = in | out)
    std::stringbuf buf1;
    buf1.sputc('1');
    std::cout << &buf1 << '\n';
    // constructeur avec chaîne en mode at-end (C++11)
    std::stringbuf buf2("test", std::ios_base::in
                              | std::ios_base::out
                              | std::ios_base::ate);
    buf2.sputc('1');
    std::cout << &buf2 << '\n';
    // test du mode append (les résultats varient selon les compilateurs)
    std::stringbuf buf3("test", std::ios_base::in
                              | std::ios_base::out
                              | std::ios_base::app);
    buf3.sputc('1');
    buf3.pubseekpos(1);
    buf3.sputc('2');
    std::cout << &buf3 << '\n';
}

Sortie : 

1
test1
est12 (Sun Studio) 2st1 (GCC)

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 Applicable à Comportement publié Comportement corrigé
LWG 432 C++98 1. la surcharge (1) n'allouait aucun objet tableau
2. la surcharge (3) ne spécifiait pas comment les séquences
d'entrée et de sortie sont initialisées 		1. limitation supprimée
2. spécifié
LWG 562 C++98 la surcharge (3) positionnait epptr() à pointer après le dernier caractère
sous-jacent si bool ( which & std:: ios_base :: out ) == true 		epptr() peut être positionné
au-delà de cette position
P0935R0 C++11 le constructeur par défaut était explicite rendu implicite

Voir aussi

construit le flux de chaîne
(fonction membre publique de std::basic_stringstream<CharT,Traits,Allocator> )