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

From cppreference.com
< cpp‎ | io‎ | 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

(constructor) | 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"