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

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

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

Constructs new string stream.

Given

- `base_type` as std::basic_ostream <CharT, Traits>, and
- `buf_type` as std::basic_stringbuf <CharT, Traits, Allocator>,

the std::basic_ostream base and the exposition-only data member `sb` are initialized as follows.

Over load | std::basic_ostream base | `sb`
--- | --- | ---
(1) | base_type( std::addressof (sb))[1] | buf_type(mode | std::ios_base::out )
(2) | buf_type( std::ios_base::out )
(3) | buf_type(str, mode | std::ios_base::out )
(4) | buf_type(std::move(str), mode | std::ios_base::out )
(5) | buf_type(mode | std::ios_base::out, a)
(6) | buf_type(str, mode | std::ios_base::out, a)
(7) | buf_type(str, std::ios_base::out, a)
(8) | buf_type(str, mode | std::ios_base::out )
(9) | std::addressof (sb) | {t, mode | std::ios_base::out, Allocator()}
(10) | {t, mode | std::ios_base::out, a}
(11) | {t, std::ios_base::out, a}
(12) | move constructed from other's std::basic_ostream base | move constructed from other.sb

1. ↑ The std::basic_iostream base was intialized with base_type(&sb) (for overloads (1,3)) until C++11.

8) This overload participates in overload resolution only if std::is_same_v <SAlloc, Allocator> is false.
9-11) These overloads participate in overload resolution only if std::is_convertible_v <const StringViewLike&, std::basic_string_view <CharT, Traits>> is true.

### Parameters

str | - | string to use as initial contents of the string stream
t | - | an object (convertible to std::basic_string_view) 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 a BitmaskType, 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_ostringstream` 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.

Feature-test macro | Value | Std | Feature
--- | --- | --- | ---
`__cpp_lib_sstream_from_string_view` | `202306L` | (C++26) | Interfacing std::stringstreams with std::string_view, (9-11)

### 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 | the 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_ostringstream/basic_ostringstream&oldid=116184"