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

From cppreference.com
< cpp‎ | io‎ | basic stringbuf
 
C++
 
Input/output library
I/O manipulators
Print functions (C++23)
C-style I/O
Buffers
(C++23)
(deprecated in C++98)
(C++20)
Streams
Abstractions
File I/O
String I/O
Array I/O
(C++23)
(C++23)
(C++23)
(deprecated in C++98)
(deprecated in C++98)
(deprecated in C++98)
Synchronized Output
(C++20)
Types
Error category interface
(C++11)
(C++11)
 
std::basic_stringbuf
 
basic_stringbuf()
    : basic_stringbuf( std::ios_base::in | std::ios_base::out ) {}
 (1) (since C++11)
(2)
explicit basic_stringbuf( std::ios_base::openmode which =
                              std::ios_base::in | std::ios_base::out );
 (until C++11)
explicit basic_stringbuf( std::ios_base::openmode which );
 (since 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)
basic_stringbuf( const basic_stringbuf& rhs ) = delete;
 (4) (since C++11)
basic_stringbuf( basic_stringbuf&& rhs );
 (5) (since C++11)
explicit basic_stringbuf( const Allocator& a )
    : basic_stringbuf( std::ios_base::in | std::ios_base::out, a ) {}
 (6) (since C++20)
basic_stringbuf( std::ios_base::openmode which, const Allocator& a );
 (7) (since C++20)
explicit basic_stringbuf( std::basic_string<CharT, Traits, Allocator>&& s,

                          std::ios_base::openmode which =

                              std::ios_base::in | std::ios_base::out );
 (8) (since 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) (since C++20)
template< class SAlloc >

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

                 std::ios_base::openmode, const Allocator& a );
 (10) (since 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 );
 (11) (since C++20)
basic_stringbuf( basic_stringbuf&& rhs, const Allocator& a );
 (12) (since C++20)
1) Default constructor. It is implementation-defined whether the sequence pointers (eback(), gptr(), egptr(), pbase(), pptr(), epptr()) are initialized to null pointers.
2) Constructs a std::basic_stringbuf object: initializes the base class by calling the default constructor of std::basic_streambuf, initializes the character sequence with an empty string, and sets the mode to which.
3) Constructs a std::basic_stringbuf object by performing the same initialization as (1), followed by initializing the associated character sequence as if by calling str(s).
4) The copy constructor is deleted; std::basic_stringbuf is not CopyConstructible.
5) Move-constructs a std::basic_stringbuf object by moving the state from another std::basic_stringbuf object rhs, including the associated string, the open mode, and the locale. It is implementation-defined whether the six sequence pointers in *this obtain the values which rhs had.
After the move, rhs is empty but usable (as if std​::​move(rhs).str() was called), and
  • Let rhs_p refer to the state of rhs just prior to this construction, the following expressions will evaluate to 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()
  • Let rhs_a refer to the state of rhs just after this construction, the following expressions will evaluate to 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()
6,7) Same as (1,2), except that a is used to construct the associated string.
8) Same as (3), except that std::move(s) is used to construct the associated string.
9,10) Constructs a std::basic_stringbuf object by performing the same initialization as (1), followed by initializing the associated string with content of s, using a as its allocator.
11) Same as (3), except the type of s's allocator is not Allocator. This overload participates in overload resolution only if SAlloc and Allocator are not the same type.
12) Same as (5), except that a is used to construct the associated string.

Parameters

s - a std::basic_string used to initialize the buffer
a - another allocator used to construct the internal std::basic_string
rhs - another basic_stringbuf
which - specifies stream open mode. It is bitmask type, the following constants are defined:
Constant Explanation
app seek to the end of stream before each write
binary open in binary mode
in open for reading
out open for writing
trunc discard the contents of the stream when opening
ate seek to the end of stream immediately after open
noreplace (C++23) open in exclusive mode

Notes

Typically called by the constructor of std::basic_stringstream.

The level of support for the open modes other than std::ios_base::in and std::ios_base::out varies among implementations. C++11 explicitly specifies the support for std::ios_base::ate in str() and in this constructor, but std::ios_base::app, std::ios_base::trunc, and std::ios_base::binary have different effects on different implementations.

Example

Demonstrates calling the constructor of std::basic_stringbuf directly:

Run this code
#include <iostream>
#include <sstream>
 
int main()
{
    // default constructor (mode = in | out)
    std::stringbuf buf1;
    buf1.sputc('1');
    std::cout << &buf1 << '\n';
 
    // string constructor in at-end mode (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 mode test (results differ among compilers)
    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';
}

Output: 

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

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 432 C++98 1. overload (2) allocated no array object
2. overload (3) did not specify how the input
    and output sequences are initialized 		1. removed the limitation
2. specified
LWG 562 C++98 overload (3) set epptr() to point one past the last underlying
character if bool(which & std::ios_base::out) == true 		epptr() can be set
beyond that position
P0935R0 C++11 default constructor was explicit made implicit

See also

 constructs the string stream
(public member function of std::basic_stringstream<CharT,Traits,Allocator>)
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/io/basic_stringbuf/basic_stringbuf&oldid=156404"