Namespaces
Variants

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

From cppreference.net
C++
Input/output library
std::basic_stringbuf
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur wurde gemäß den Anforderungen unverändert beibehalten.)
(1)
(bis C++11)
explicit basic_stringbuf ( std:: ios_base :: openmode which ) ;
(seit C++11)
basic_stringbuf ( )
: basic_stringbuf ( std:: ios_base :: in | std:: ios_base :: out ) { }
(2) (seit 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 which =

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

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

std:: ios_base :: openmode Modus, const Allocator & a ) ;
(8) (seit 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) (seit C++20)
template < class StringViewLike >

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

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

basic_stringbuf ( const StringViewLike & t,

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

Die std::basic_streambuf Basis und die exposition-only Datenmitglieder buf und mode werden wie folgt initialisiert.

Nach der Initialisierung dieser Teilobjekte initialisieren die Überladungen (3-12) die Eingabe- und Ausgabesequenzen, als ob init_buf_ptrs () aufgerufen würde.

Überladung std::basic_streambuf Basis buf mode
(1) standardinitialisiert implementierungsdefiniert
(siehe unten) 		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
(kopierkonstruiert) 		std :: move ( rhs ) . str ( ) rhs. mode
(14) { std :: move ( rhs ) . str ( ) , a }
1,2) Überladung (1) (bis C++11) (2) (seit C++11) ist der Standardkonstruktor. Es ist implementierungsdefiniert, ob die Sequenzzeiger ( eback() , gptr() , egptr() , pbase() , pptr() , epptr() ) auf Nullzeiger initialisiert werden.
5,6) Wenn die Konstruktion abgeschlossen ist, str. empty ( ) ist true .
7) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_same_v < SAlloc, Allocator > false ist.
10-12) Konvertiert implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , dann wird es wie oben in der Tabelle verwendet.
Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >> true ist.
13,14) Überladung (13) ist der Move-Konstruktor. Es ist implementierungsdefiniert, ob die sechs Sequenzzeiger in * this die Werte erhalten, die rhs hatte.
When the construction is complete, rhs is empty but usable, and
  • Lassen Sie rhs_p auf den Zustand von rhs unmittelbar vor dieser Konstruktion verweisen, dann werden die folgenden Ausdrücke zu true ausgewertet:
  • 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 ( )
*Hinweis: Der gesamte Code innerhalb der Tags wurde gemäß den Anforderungen nicht übersetzt, da es sich um C++-Code handelt. Die HTML-Struktur und Formatierung bleibt vollständig erhalten.*
  • Lassen Sie rhs_a den Zustand von rhs direkt nach dieser Konstruktion bezeichnen, dann werden die folgenden Ausdrücke zu true ausgewertet:
  • ! 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 ( )
**Anmerkung:** Da der gesamte Inhalt innerhalb von ` ` Tags liegt (was auf Code-Highlighting hinweist) und gemäß Ihrer Anweisung C++-spezifische Begriffe nicht übersetzt werden sollen, bleibt der gesamte Code unverändert. Die logischen Ausdrücke stellen C++-Vergleiche von Stream-Buffer-Zeigern dar und wurden nicht übersetzt.
15) Der Kopierkonstruktor ist gelöscht; std::basic_stringbuf ist nicht CopyConstructible .

Inhaltsverzeichnis

Parameter

s - ein std::basic_string zum Initialisieren des Puffers
t - ein Objekt (konvertierbar zu std::basic_string_view ) zum Initialisieren des Puffers
a - ein weiterer Allokator zum Konstruieren der internen std::basic_string
rhs - ein weiterer basic_stringbuf
which - gibt den Stream-Öffnungsmodus an. Es ist ein Bitmask-Typ, folgende Konstanten sind definiert:
Konstante Erklärung
app vor jedem Schreibvorgang ans Ende des Streams positionieren
binary im Binärmodus öffnen
in zum Lesen öffnen
out zum Schreiben öffnen
trunc Inhalte beim Öffnen verwerfen
ate unmittelbar nach dem Öffnen ans Ende des Streams positionieren
noreplace (C++23) im exklusiven Modus öffnen

Hinweise

Typischerweise aufgerufen vom Konstruktor von std::basic_stringstream .

Die Unterstützung für die Öffnungsmodi außer std::ios_base::in und std::ios_base::out variiert zwischen verschiedenen Implementierungen. C++11 spezifiziert explizit die Unterstützung für std::ios_base::ate in str() und in diesem Konstruktor, aber std::ios_base::app , std::ios_base::trunc und std::ios_base::binary haben unterschiedliche Auswirkungen in verschiedenen Implementierungen.

Feature-Test Makro Wert Std Funktion
__cpp_lib_sstream_from_string_view 202306L (C++26) Verbindung von String-Streams mit std::string_view

Beispiel

Demonstriert den direkten Aufruf des Konstruktors von std::basic_stringbuf :

Diesen Code ausführen 
#include <iostream>
#include <sstream>
int main()
{
    // Standardkonstruktor (mode = in | out)
    std::stringbuf buf1;
    buf1.sputc('1');
    std::cout << &buf1 << '\n';
    // String-Konstruktor im At-End-Modus (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';
    // Append-Modus-Test (Ergebnisse variieren zwischen Compilern)
    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';
}

Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 432 C++98 1. Überladung (1) allozierte kein Array-Objekt
2. Überladung (3) spezifizierte nicht, wie die Eingabe-
und Ausgabesequenzen initialisiert werden 		1. Einschränkung entfernt
2. spezifiziert
LWG 562 C++98 Überladung (3) setzte epptr() auf eine Position hinter dem letzten zugrundeliegenden
Zeichen, wenn bool ( welches & std:: ios_base :: out ) == true 		epptr() kann darüber hinaus
gesetzt werden
P0935R0 C++11 der Standardkonstruktor war explizit implizit gemacht

Siehe auch

Konstruiert den String-Stream
(öffentliche Elementfunktion von std::basic_stringstream<CharT,Traits,Allocator> )