Namespaces
Variants

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

From cppreference.net
C++
Input/output library
std::basic_stringbuf
(1)
(hasta C++11)
explicit basic_stringbuf ( std:: ios_base :: openmode which ) ;
(desde C++11)
basic_stringbuf ( )
: basic_stringbuf ( std:: ios_base :: in | std:: ios_base :: out ) { }
(2) (desde C++11)
explicit

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

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

std:: ios_base :: openmode modo =

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

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

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

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

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

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

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

basic_stringbuf ( const StringViewLike & t,

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

La std::basic_streambuf base y los miembros de datos de solo exposición buf y mode se inicializan de la siguiente manera.

Después de inicializar estos subobjetos, las sobrecargas (3-12) inicializan las secuencias de entrada y salida como si llamaran a init_buf_ptrs () .

Sobrecarga std::basic_streambuf base buf mode
(1) inicializado por defecto definido por la implementación
(ver abajo) 		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
(construido por copia) 		std :: move ( rhs ) . str ( ) rhs. mode
(14) { std :: move ( rhs ) . str ( ) , a }
1,2) Sobrecarga (1) (until C++11) (2) (since C++11) es el constructor por defecto. Está definido por la implementación si los punteros de secuencia ( eback() , gptr() , egptr() , pbase() , pptr() , epptr() ) se inicializan a punteros nulos.
5,6) Cuando la construcción se completa, str. empty ( ) es true .
7) Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_same_v < SAlloc, Allocator > es false .
10-12) Convierte implícitamente t a una vista de cadena sv como si fuera mediante std:: basic_string_view < CharT, Traits > sv = t ; , luego se utiliza como se muestra arriba en la tabla.
Estas sobrecargas participan en la resolución de sobrecarga solo si std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >> es true .
13,14) Sobrecarga (13) es el constructor de movimiento. Está definido por la implementación si los seis punteros de secuencia en * this obtienen los valores que rhs tenía.
When the construction is complete, rhs is empty but usable, and
  • Sea rhs_p la referencia al estado de rhs justo antes de esta construcción, las siguientes expresiones evaluarán a 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 ( )
  • Sea rhs_a el estado de rhs justo después de esta construcción, las siguientes expresiones evaluarán a 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 ( )
15) El constructor de copia está eliminado; std::basic_stringbuf no es CopyConstructible .

Contenidos

Parámetros

s - un std::basic_string utilizado para inicializar el búfer
t - un objeto (convertible a std::basic_string_view ) utilizado para inicializar el búfer
a - otro asignador utilizado para construir el std::basic_string interno
rhs - otro basic_stringbuf
which - especifica el modo de apertura del flujo. Es un tipo de máscara de bits, se definen las siguientes constantes:
Constante Explicación
app buscar al final del flujo antes de cada escritura
binary abrir en modo binario
in abrir para lectura
out abrir para escritura
trunc descartar el contenido del flujo al abrir
ate buscar al final del flujo inmediatamente después de abrir
noreplace (C++23) abrir en modo exclusivo

Notas

Normalmente llamado por el constructor de std::basic_stringstream .

El nivel de soporte para los modos de apertura distintos a std::ios_base::in y std::ios_base::out varía entre implementaciones. C++11 especifica explícitamente el soporte para std::ios_base::ate en str() y en este constructor, pero std::ios_base::app , std::ios_base::trunc , y std::ios_base::binary tienen efectos diferentes en distintas implementaciones.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_sstream_from_string_view 202306L (C++26) Interconexión de flujos de cadena con std::string_view

Ejemplo

Demuestra llamar al constructor de std::basic_stringbuf directamente:

Ejecutar este código 
#include <iostream>
#include <sstream>
int main()
{
    // constructor por defecto (mode = in | out)
    std::stringbuf buf1;
    buf1.sputc('1');
    std::cout << &buf1 << '\n';
    // constructor de cadena en modo 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';
    // prueba de modo append (los resultados varían entre compiladores)
    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';
}

Salida: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 432 C++98 1. la sobrecarga (1) no asignaba ningún objeto array
2. la sobrecarga (3) no especificaba cómo se inicializan
las secuencias de entrada y salida 		1. se eliminó la limitación
2. se especificó
LWG 562 C++98 la sobrecarga (3) establecía epptr() para apuntar un carácter más allá del último carácter
subyacente si bool ( which & std:: ios_base :: out ) == true 		epptr() puede establecerse
más allá de esa posición
P0935R0 C++11 el constructor por defecto era explícito se hizo implícito

Véase también

construye el flujo de cadena
(función miembro pública de std::basic_stringstream<CharT,Traits,Allocator> )