std::basic_...stringstream(3)

std::basic_stringstream::basic_stringstream 💅

(from the C++ Standard Library manual — yes bestie, we're doing constructors today 🫶)

💖 NAME 💖

std::basic_stringstream::basic_stringstream — the constructor for std::basic_stringstream, aka how your string stream is born. 🎀

✨ Synopsis ✨

Okay so there are twelve overloads and we are listing every single one, no cap. 👑

// (1)
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)

// (2) (since C++11)
basic_stringstream()
    : basic_stringstream(std::ios_base::in |
                         std::ios_base::out) {}

// (3)
explicit basic_stringstream
    ( const std::basic_string<CharT, Traits, Allocator>& str,
      std::ios_base::openmode mode =
          std::ios_base::in | std::ios_base::out );

// (4) (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 );

// (5) (since C++20)
basic_stringstream( std::ios_base::openmode mode, const
    Allocator& a );

// (6) (since C++20)
template< class SAlloc >
basic_stringstream( const std::basic_string<CharT, Traits,
    SAlloc>& str,
    std::ios_base::openmode mode, const
    Allocator& a );

// (7) (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) {}

// (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++26)
template< class StringViewLike >
explicit basic_stringstream
    ( const StringViewLike& t,
      std::ios_base::openmode mode =
          std::ios_base::in | std::ios_base::out );

// (10) (since C++26)
template< class StringViewLike >
basic_stringstream( const StringViewLike& t,
    std::ios_base::openmode mode, const
    Allocator& a );

// (11) (since C++26)
template< class StringViewLike >
basic_stringstream( const StringViewLike& t, const Allocator&
    a );

// (12) (since C++11)
basic_stringstream( basic_stringstream&& other );

Constructs new string stream. 🫧

Given

• base_type as std::basic_iostream<CharT, Traits>, and
• buf_type as std::basic_stringbuf<CharT, Traits, Allocator>,

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

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

[1] The std::basic_iostream base was initialized 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:
  • 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. So like… don't spam constructors if you can just reuse, bestie. 💸

⭐ Feature-test macro ⭐

• __cpp_lib_sstream_from_string_view — value 202306L — std (C++26) — feature: Interfacing std::stringstreams with std::string_view, (9-11).

🍓 Example 🍓

Run this code, bestie:

#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.

• P0935R0 — applied to 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>).

---

xoxo bestie 💖 source: http://cppreference.com · version/date: 2024.06.10 · page: std::basic_...stringstream(3) ✨