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

From cppreference.com
< cpp‎ | io‎ | basic stringstream

basic_stringstream() : basic_stringstream(std::ios_base::in | std::ios_base::out) { } | (1) | (since C++11)
| (2) |
explicit basic_stringstream( std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out ); |  | (until C++11)
explicit basic_stringstream( std::ios_base::openmode mode ); |  | (since C++11)
explicit basic_stringstream( const std::basic_string<CharT,Traits,Allocator>& str, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out ); | (3) |
basic_stringstream( basic_stringstream&& other ); | (4) | (since C++11)
basic_stringstream( std::ios_base::openmode mode, const Allocator& a ); | (5) | (since C++20)
explicit basic_stringstream( std::basic_string<CharT,Traits,Allocator>&& str, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out ); | (6) | (since C++20)
template<class SAlloc> basic_stringstream( const std::basic_string<CharT,Traits,SAlloc>& str, const Allocator& a ) : basic_stringstream(str, std::ios_base::in | std::ios_base::out, a) { } | (7) | (since C++20)
template<class SAlloc> basic_stringstream( const std::basic_string<CharT,Traits,SAlloc>& str, std::ios_base::openmode mode, const Allocator& a ); | (8) | (since C++20)
template<class SAlloc> explicit basic_stringstream( const std::basic_string<CharT,Traits,SAlloc>& str, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out ); | (9) | (since C++20)

Constructs new string stream.

1) Default constructor. Constructs new underlying string device with the default open mode
2) Constructs new underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(mode).
3) Uses a copy of `str` as initial contents of the underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(str, mode).
4) Move constructor. Constructs the string stream with the state of `other` using move semantics.
5) Constructs new underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(mode, a).
6) Move-construct the contents of the underlying string device with `str`. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(std::move(str), mode).
7) Constructs new underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(str, std::ios_base::in | std::ios_base::out, a).
8) Constructs new underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(str, mode, a).
9) Constructs new underlying string device. The underlying `basic_stringbuf` object is constructed as basic_stringbuf<Char,Traits,Allocator>(str, mode). This overload participates in overload resolution only if `SAlloc` and `Allocator` are not the same type.

### Parameters

str | - | string to use as initial contents of the string stream
a | - | allocator used for allocating the contents of the string stream
mode | - | 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
other | - | another string stream to use as source

### Notes

Construction of one-off `basic_stringstream` objects in a tight loop, such as when used for string conversion, may be significantly more costly than calling str to reuse the same object.

### Example

Run this code

    #include <iostream>
    #include <sstream>
    int main()
    {
        // default constructor (input/output stream)
        std::stringstream buf1;
        buf1 << 7;
        int n = 0;
        buf1 >> n;
        std::cout << "buf1 = " << buf1.str() << " n = " << n << '\n';

        // input stream
        std::istringstream inbuf("-10");
        inbuf >> n;
        std::cout << "n = " << n << '\n';

        // output stream in append mode (C++11)
        std::ostringstream buf2("test", std::ios_base::ate);
        buf2 << '1';
        std::cout << buf2.str() << '\n';
    }

Output:

    buf1 = 7 n = 7
    n = -10
    test1

### Defect reports

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

DR | Applied to | Behavior as published | Correct behavior
--- | --- | --- | ---
P0935R0 | C++11 | default constructor was explicit | made implicit

### See also

str | gets or sets the contents of underlying string device object (public member function)
(constructor) | constructs a `basic_stringbuf` object (public member function of `std::basic_stringbuf<CharT,Traits,Allocator>`)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/io/basic_stringstream/basic_stringstream&oldid=116183"