[string.streams] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpbd72nqoc/{from.md → to.md} +290 -112

tmp/tmpbd72nqoc/{from.md → to.md} RENAMED Viewed

@@ -2,45 +2,45 @@
 ### Header `<sstream>` synopsis <a id="sstream.syn">[[sstream.syn]]</a>
 ``` cpp
 namespace std {
- template<class charT, class traits = char_traits<charT>,
- class Allocator = allocator<charT>>
     class basic_stringbuf;
   template<class charT, class traits, class Allocator>
     void swap(basic_stringbuf<charT, traits, Allocator>& x,
               basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
   using stringbuf  = basic_stringbuf<char>;
   using wstringbuf = basic_stringbuf<wchar_t>;
- template<class charT, class traits = char_traits<charT>,
- class Allocator = allocator<charT>>
     class basic_istringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_istringstream<charT, traits, Allocator>& x,
               basic_istringstream<charT, traits, Allocator>& y);
   using istringstream  = basic_istringstream<char>;
   using wistringstream = basic_istringstream<wchar_t>;
- template<class charT, class traits = char_traits<charT>,
- class Allocator = allocator<charT>>
     class basic_ostringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_ostringstream<charT, traits, Allocator>& x,
               basic_ostringstream<charT, traits, Allocator>& y);
   using ostringstream  = basic_ostringstream<char>;
   using wostringstream = basic_ostringstream<wchar_t>;
- template<class charT, class traits = char_traits<charT>,
- class Allocator = allocator<charT>>
     class basic_stringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_stringstream<charT, traits, Allocator>& x,
               basic_stringstream<charT, traits, Allocator>& y);
@@ -58,18 +58,17 @@ described in  [[string.classes]].
 #### General <a id="stringbuf.general">[[stringbuf.general]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
   class basic_stringbuf : public basic_streambuf<charT, traits> {
   public:
     using char_type      = charT;
-    using int_type       = typename traits::int_type;
-    using pos_type       = typename traits::pos_type;
-    using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringbuf.cons], constructors
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
@@ -93,10 +92,17 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringbuf(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in | ios_base::out);
     basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
     // [stringbuf.assign], assignment and swap
@@ -115,10 +121,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
   protected:
     // [stringbuf.virtuals], overridden virtual functions
     int_type underflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
@@ -133,11 +141,11 @@ namespace std {
                        = ios_base::in | ios_base::out) override;
   private:
     ios_base::openmode mode;                        // exposition only
     basic_string<charT, traits, Allocator> buf;     // exposition only
-    void init_buf_ptrs();                           // exposition only
   };
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
@@ -151,22 +159,22 @@ initialization is presented here as:
 - `ios_base::openmode mode`, has `in` set if the input sequence can be
   read, and `out` set if the output sequence can be written.
 - `basic_string<charT, traits, Allocator> buf` contains the underlying
   character sequence.
-- `init_buf_ptrs()` sets the base class’ get area [[streambuf.get.area]]
   and put area [[streambuf.put.area]] pointers after initializing,
-  moving from, or assigning to `buf` accordingly.
 #### Constructors <a id="stringbuf.cons">[[stringbuf.cons]]</a>
 ``` cpp
 explicit basic_stringbuf(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], and `mode` with `which`. It is
 *implementation-defined* whether the sequence pointers (`eback()`,
 `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) are initialized to
 null pointers.
 *Ensures:* `str().empty()` is `true`.
@@ -176,43 +184,43 @@ explicit basic_stringbuf(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `s`, then calls
-`init_buf_ptrs()`.
 ``` cpp
 basic_stringbuf(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `a`, then calls
-`init_buf_ptrs()`.
 *Ensures:* `str().empty()` is `true`.
 ``` cpp
 explicit basic_stringbuf(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `std::move(s)`,
-then calls `init_buf_ptrs()`.
 ``` cpp
 template<class SAlloc>
   basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `{s,a}`, then
-calls `init_buf_ptrs()`.
 ``` cpp
 template<class SAlloc>
   explicit basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
@@ -220,21 +228,44 @@ template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `s`, then calls
-`init_buf_ptrs()`.
 ``` cpp
 basic_stringbuf(basic_stringbuf&& rhs);
 basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
 ```
 *Effects:* Copy constructs the base class from `rhs` and initializes
-`mode` with `rhs.mode`. In the first form `buf` is initialized from
-`std::move(rhs).str()`. In the second form `buf` is initialized from
 `{std::move(rhs).str(), a}`. It is *implementation-defined* whether the
 sequence pointers in `*this` (`eback()`, `gptr()`, `egptr()`, `pbase()`,
 `pptr()`, `epptr()`) obtain the values which `rhs` had.
 *Ensures:* Let `rhs_p` refer to the state of `rhs` just prior to this
@@ -277,19 +308,19 @@ void swap(basic_stringbuf& rhs) noexcept(see below);
 *Effects:* Exchanges the state of `*this` and `rhs`.
 *Remarks:* The exception specification is equivalent to:
 `allocator_traits<Allocator>::propagate_on_container_swap::value ||`
-`allocator_traits<Allocator>::is_always_equal::value`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="stringbuf.members">[[stringbuf.members]]</a>
 The member functions getting the underlying character sequence all refer
 to a `high_mark` value, where `high_mark` represents the position one
@@ -300,39 +331,42 @@ of the `str` member functions passing a `basic_string` as an argument.
 In the latter case, all characters initialized prior to the call are now
 considered uninitialized (except for those characters re-initialized by
 the new `basic_string`).
 ``` cpp
-void init_buf_ptrs(); // exposition only
 ```
-*Effects:* Initializes the input and output sequences from `buf`
-according to `mode`.
 *Ensures:*
-- If `ios_base::out` is set in `mode`, `pbase()` points to `buf.front()`
-  and `epptr() >= pbase() + buf.size()` is `true`;
- - in addition, if `ios_base::ate` is set in `mode`,
-    `pptr() == pbase() + buf.size()` is `true`,
   - otherwise `pptr() == pbase()` is `true`.
-- If `ios_base::in` is set in `mode`, `eback()` points to `buf.front()`,
- and `(gptr() == eback() && egptr() == eback() + buf.size())` is
   `true`.
 [*Note 1*: For efficiency reasons, stream buffer operations can violate
-invariants of `buf` while it is held encapsulated in the
 `basic_stringbuf`, e.g., by writing to characters in the range
-\[`buf.data() + buf.size()`, `buf.data() + buf.capacity()`). All
-operations retrieving a `basic_string` from `buf` ensure that the
-`basic_string` invariants hold on the returned value. — *end note*]
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
-*Returns:* `buf.get_allocator()`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -346,11 +380,11 @@ return basic_string<charT, traits, Allocator>(view(), get_allocator());
 template<class SAlloc>
   basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
 ```
 *Constraints:* `SAlloc` is a type that qualifies as an
-allocator [[container.requirements.general]].
 *Effects:* Equivalent to:
 ``` cpp
 return basic_string<charT, traits, SAlloc>(view(), sa);
@@ -360,11 +394,11 @@ return basic_string<charT, traits, SAlloc>(view(), sa);
 basic_string<charT, traits, Allocator> str() &&;
 ```
 *Ensures:* The underlying character sequence `buf` is empty and
 `pbase()`, `pptr()`, `epptr()`, `eback()`, `gptr()`, and `egptr()` are
-initialized as if by calling `init_buf_ptrs()` with an empty `buf`.
 *Returns:* A `basic_string<charT, traits, Allocator>` object move
 constructed from the `basic_stringbuf`’s underlying character sequence
 in `buf`. This can be achieved by first adjusting `buf` to have the same
 content as `view()`.
@@ -376,13 +410,13 @@ basic_string_view<charT, traits> view() const noexcept;
 Let `sv` be `basic_string_view<charT, traits>`.
 *Returns:* A `sv` object referring to the `basic_stringbuf`’s underlying
 character sequence in `buf`:
-- If `ios_base::out` is set in `mode`, then
   `sv(pbase(), high_mark - pbase())` is returned.
-- Otherwise, if `ios_base::in` is set in `mode`, then
   `sv(eback(), egptr() - eback())` is returned.
 - Otherwise, `sv()` is returned.
 [*Note 2*: Using the returned `sv` object after destruction or
 invalidation of the character sequence underlying `*this` is undefined
@@ -394,11 +428,11 @@ void str(const basic_string<charT, traits, Allocator>& s);
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
-init_buf_ptrs();
 ```
 ``` cpp
 template<class SAlloc>
   void str(const basic_string<charT, traits, SAlloc>& s);
@@ -408,22 +442,39 @@ template<class SAlloc>
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
-init_buf_ptrs();
 ```
 ``` cpp
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 buf = std::move(s);
-init_buf_ptrs();
 ```
 #### Overridden virtual functions <a id="stringbuf.virtuals">[[stringbuf.virtuals]]</a>
 ``` cpp
@@ -445,11 +496,11 @@ sequence, if possible, in one of three ways:
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   input sequence has a putback position available, and if
   `traits::eq(to_char_type(c), gptr()[-1])` returns `true`, assigns
   `gptr() - 1` to `gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
-  input sequence has a putback position available, and if `mode` `&`
   `ios_base::out` is nonzero, assigns `c` to `*–gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true` and if the
   input sequence has a putback position available, assigns `gptr() - 1`
   to `gptr()`. Returns: `traits::not_eof(c)`.
@@ -477,14 +528,14 @@ sequence, if possible, in one of two ways:
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
 The function can make a write position available only if `ios_base::out`
-is set in `mode`. To make a write position available, the function
 reallocates (or initially allocates) an array object with a sufficient
 number of elements to hold the current array object (if any), plus at
-least one additional write position. If `ios_base::in` is set in `mode`,
 the function alters the read end pointer `egptr()` to point just past
 the new write position.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
@@ -554,18 +605,17 @@ effect.
 #### General <a id="istringstream.general">[[istringstream.general]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
   class basic_istringstream : public basic_istream<charT, traits> {
   public:
     using char_type      = charT;
-    using int_type       = typename traits::int_type;
-    using pos_type       = typename traits::pos_type;
-    using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [istringstream.cons], constructors
     basic_istringstream() : basic_istringstream(ios_base::in) {}
@@ -587,10 +637,16 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_istringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in);
     basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
     basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
@@ -608,10 +664,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
@@ -621,51 +679,54 @@ The class `basic_istringstream<charT, traits, Allocator>` supports
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated storage. For the sake of exposition, the maintained data is
 presented here as:
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="istringstream.cons">[[istringstream.cons]]</a>
 ``` cpp
 explicit basic_istringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 basic_istringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -673,35 +734,59 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_istringstream(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 basic_istringstream(basic_istringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
-`basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
-contained `basic_stringbuf`.
 #### Swap <a id="istringstream.swap">[[istringstream.swap]]</a>
 ``` cpp
 void swap(basic_istringstream& rhs);
@@ -718,20 +803,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="istringstream.members">[[istringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -773,24 +858,34 @@ template<class SAlloc>
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_ostringstream` <a id="ostringstream">[[ostringstream]]</a>
 #### General <a id="ostringstream.general">[[ostringstream.general]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
   class basic_ostringstream : public basic_ostream<charT, traits> {
   public:
     using char_type      = charT;
-    using int_type       = typename traits::int_type;
-    using pos_type       = typename traits::pos_type;
-    using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [ostringstream.cons], constructors
     basic_ostringstream() : basic_ostringstream(ios_base::out) {}
@@ -812,10 +907,16 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_ostringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out);
     basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
     basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
@@ -834,10 +935,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
@@ -846,51 +949,54 @@ namespace std {
 The class `basic_ostringstream<charT, traits, Allocator>` supports
 writing objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf` object to control the associated storage. For
 the sake of exposition, the maintained data is presented here as:
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="ostringstream.cons">[[ostringstream.cons]]</a>
 ``` cpp
 explicit basic_ostringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 basic_ostringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::out, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -898,11 +1004,12 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -912,23 +1019,44 @@ template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 basic_ostringstream(basic_ostringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
-`basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` to install the
-contained `basic_stringbuf`.
 #### Swap <a id="ostringstream.swap">[[ostringstream.swap]]</a>
 ``` cpp
 void swap(basic_ostringstream& rhs);
@@ -945,20 +1073,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ostringstream.members">[[ostringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -1000,24 +1128,34 @@ template<class SAlloc>
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_stringstream` <a id="stringstream">[[stringstream]]</a>
 #### General <a id="stringstream.general">[[stringstream.general]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
   class basic_stringstream : public basic_iostream<charT, traits> {
   public:
     using char_type      = charT;
-    using int_type       = typename traits::int_type;
-    using pos_type       = typename traits::pos_type;
-    using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringstream.cons], constructors
     basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
@@ -1039,10 +1177,17 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out | ios_base::in);
     basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
     basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
@@ -1061,13 +1206,15 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
-    basic_stringbuf<charT, traits> sb; // exposition only
   };
 }
 ```
 The class template `basic_stringstream<charT, traits>` supports reading
@@ -1075,50 +1222,50 @@ and writing from objects of class
 `basic_string<charT, traits, Allocator>`. It uses a
 `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(which)`.
 ``` cpp
 explicit basic_stringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which)`.
 ``` cpp
 basic_stringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(which, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_stringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -1126,12 +1273,12 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_stringstream(
@@ -1140,23 +1287,43 @@ template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which)`
 [[stringbuf.cons]].
 ``` cpp
 basic_stringstream(basic_stringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
-`basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
-contained `basic_stringbuf`.
 #### Swap <a id="stringstream.swap">[[stringstream.swap]]</a>
 ``` cpp
 void swap(basic_stringstream& rhs);
@@ -1173,20 +1340,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -1228,5 +1395,16 @@ template<class SAlloc>
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`

 ### Header `<sstream>` synopsis <a id="sstream.syn">[[sstream.syn]]</a>
 ``` cpp
 namespace std {
+ // [stringbuf], class template basic_stringbuf
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_stringbuf;
   template<class charT, class traits, class Allocator>
     void swap(basic_stringbuf<charT, traits, Allocator>& x,
               basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
   using stringbuf  = basic_stringbuf<char>;
   using wstringbuf = basic_stringbuf<wchar_t>;
+ // [istringstream], class template basic_istringstream
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_istringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_istringstream<charT, traits, Allocator>& x,
               basic_istringstream<charT, traits, Allocator>& y);
   using istringstream  = basic_istringstream<char>;
   using wistringstream = basic_istringstream<wchar_t>;
+ // [ostringstream], class template basic_ostringstream
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_ostringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_ostringstream<charT, traits, Allocator>& x,
               basic_ostringstream<charT, traits, Allocator>& y);
   using ostringstream  = basic_ostringstream<char>;
   using wostringstream = basic_ostringstream<wchar_t>;
+ // [stringstream], class template basic_stringstream
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_stringstream;
   template<class charT, class traits, class Allocator>
     void swap(basic_stringstream<charT, traits, Allocator>& x,
               basic_stringstream<charT, traits, Allocator>& y);
 #### General <a id="stringbuf.general">[[stringbuf.general]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_stringbuf : public basic_streambuf<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringbuf.cons], constructors
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringbuf(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in | ios_base::out);
+    template<class T>
+      explicit basic_stringbuf(const T& t,
+                               ios_base::openmode which = ios_base::in | ios_base::out);
+    template<class T>
+      basic_stringbuf(const T& t, const Allocator& a);
+    template<class T>
+      basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
     basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
     // [stringbuf.assign], assignment and swap
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   protected:
     // [stringbuf.virtuals], overridden virtual functions
     int_type underflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
                        = ios_base::in | ios_base::out) override;
   private:
     ios_base::openmode mode;                        // exposition only
     basic_string<charT, traits, Allocator> buf;     // exposition only
+    void init-buf-ptrs();                           // exposition only
   };
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
 - `ios_base::openmode mode`, has `in` set if the input sequence can be
   read, and `out` set if the output sequence can be written.
 - `basic_string<charT, traits, Allocator> buf` contains the underlying
   character sequence.
+- `init-buf-ptrs()` sets the base class’ get area [[streambuf.get.area]]
   and put area [[streambuf.put.area]] pointers after initializing,
+  moving from, or assigning to *`buf`* accordingly.
 #### Constructors <a id="stringbuf.cons">[[stringbuf.cons]]</a>
 ``` cpp
 explicit basic_stringbuf(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], and *mode* with `which`. It is
 *implementation-defined* whether the sequence pointers (`eback()`,
 `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) are initialized to
 null pointers.
 *Ensures:* `str().empty()` is `true`.
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `s`, then calls
+*`init-buf-ptrs`*`()`.
 ``` cpp
 basic_stringbuf(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `a`, then calls
+*`init-buf-ptrs`*`()`.
 *Ensures:* `str().empty()` is `true`.
 ``` cpp
 explicit basic_stringbuf(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `std::move(s)`,
+then calls *`init-buf-ptrs`*`()`.
 ``` cpp
 template<class SAlloc>
   basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `{s,a}`, then
+calls *`init-buf-ptrs`*`()`.
 ``` cpp
 template<class SAlloc>
   explicit basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `s`, then calls
+*`init-buf-ptrs`*`()`.
+``` cpp
+template<class T>
+  explicit basic_stringbuf(const T& t, ios_base::openmode which = ios_base::in | ios_base::out);
+template<class T>
+  basic_stringbuf(const T& t, const Allocator& a);
+template<class T>
+  basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::in | ios_base::out` for the overload with no
+parameter `which`, and `a` be `Allocator()` for the overload with no
+parameter `a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Creates a variable `sv` as if by
+`basic_string_view<charT, traits> sv = t`, then value-initializes the
+base class, initializes *mode* with `which`, and
+direct-non-list-initializes *buf* with `sv, a`, then calls
+*`init-buf-ptrs`*`()`.
 ``` cpp
 basic_stringbuf(basic_stringbuf&& rhs);
 basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
 ```
 *Effects:* Copy constructs the base class from `rhs` and initializes
+*mode* with `rhs.mode`. In the first form `buf` is initialized from
+`std::move(rhs).str()`. In the second form *buf* is initialized from
 `{std::move(rhs).str(), a}`. It is *implementation-defined* whether the
 sequence pointers in `*this` (`eback()`, `gptr()`, `egptr()`, `pbase()`,
 `pptr()`, `epptr()`) obtain the values which `rhs` had.
 *Ensures:* Let `rhs_p` refer to the state of `rhs` just prior to this
 *Effects:* Exchanges the state of `*this` and `rhs`.
 *Remarks:* The exception specification is equivalent to:
 `allocator_traits<Allocator>::propagate_on_container_swap::value ||`
+`allocator_traits<Allocator>::is_always_equal::value`
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="stringbuf.members">[[stringbuf.members]]</a>
 The member functions getting the underlying character sequence all refer
 to a `high_mark` value, where `high_mark` represents the position one
 In the latter case, all characters initialized prior to the call are now
 considered uninitialized (except for those characters re-initialized by
 the new `basic_string`).
 ``` cpp
+void init-buf-ptrs();
 ```
+*Effects:* Initializes the input and output sequences from *buf*
+according to *mode*.
 *Ensures:*
+- If `ios_base::out` is set in *mode*, `pbase()` points to
+ *`buf`*`.front()` and `epptr() >= pbase() + `*`buf`*`.size()` is
+  `true`;
+  - in addition, if `ios_base::ate` is set in *mode*,
+    `pptr() == pbase() + `*`buf`*`.size()` is `true`,
   - otherwise `pptr() == pbase()` is `true`.
+- If `ios_base::in` is set in *mode*, `eback()` points to
+ *`buf`*`.front()`, and
+  `(gptr() == eback() && egptr() == eback() + `*`buf`*`.size())` is
   `true`.
 [*Note 1*: For efficiency reasons, stream buffer operations can violate
+invariants of *buf* while it is held encapsulated in the
 `basic_stringbuf`, e.g., by writing to characters in the range
+[*`buf`*`.data() + `*`buf`*`.size()`,
+*`buf`*`.data() + `*`buf`*`.capacity()`). All operations retrieving a
+`basic_string` from `buf` ensure that the `basic_string` invariants hold
+on the returned value. — *end note*]
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
+*Returns:* *`buf`*`.get_allocator()`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 template<class SAlloc>
   basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
 ```
 *Constraints:* `SAlloc` is a type that qualifies as an
+allocator [[container.reqmts]].
 *Effects:* Equivalent to:
 ``` cpp
 return basic_string<charT, traits, SAlloc>(view(), sa);
 basic_string<charT, traits, Allocator> str() &&;
 ```
 *Ensures:* The underlying character sequence `buf` is empty and
 `pbase()`, `pptr()`, `epptr()`, `eback()`, `gptr()`, and `egptr()` are
+initialized as if by calling *`init-buf-ptrs`*`()` with an empty `buf`.
 *Returns:* A `basic_string<charT, traits, Allocator>` object move
 constructed from the `basic_stringbuf`’s underlying character sequence
 in `buf`. This can be achieved by first adjusting `buf` to have the same
 content as `view()`.
 Let `sv` be `basic_string_view<charT, traits>`.
 *Returns:* A `sv` object referring to the `basic_stringbuf`’s underlying
 character sequence in `buf`:
+- If `ios_base::out` is set in *mode*, then
   `sv(pbase(), high_mark - pbase())` is returned.
+- Otherwise, if `ios_base::in` is set in *mode*, then
   `sv(eback(), egptr() - eback())` is returned.
 - Otherwise, `sv()` is returned.
 [*Note 2*: Using the returned `sv` object after destruction or
 invalidation of the character sequence underlying `*this` is undefined
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
+init-buf-ptrs();
 ```
 ``` cpp
 template<class SAlloc>
   void str(const basic_string<charT, traits, SAlloc>& s);
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
+init-buf-ptrs();
 ```
 ``` cpp
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 buf = std::move(s);
+init-buf-ptrs();
+```
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+buf = sv;
+init-buf-ptrs();
 ```
 #### Overridden virtual functions <a id="stringbuf.virtuals">[[stringbuf.virtuals]]</a>
 ``` cpp
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   input sequence has a putback position available, and if
   `traits::eq(to_char_type(c), gptr()[-1])` returns `true`, assigns
   `gptr() - 1` to `gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
+  input sequence has a putback position available, and if *mode* `&`
   `ios_base::out` is nonzero, assigns `c` to `*–gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true` and if the
   input sequence has a putback position available, assigns `gptr() - 1`
   to `gptr()`. Returns: `traits::not_eof(c)`.
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
 The function can make a write position available only if `ios_base::out`
+is set in *mode*. To make a write position available, the function
 reallocates (or initially allocates) an array object with a sufficient
 number of elements to hold the current array object (if any), plus at
+least one additional write position. If `ios_base::in` is set in *mode*,
 the function alters the read end pointer `egptr()` to point just past
 the new write position.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
 #### General <a id="istringstream.general">[[istringstream.general]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_istringstream : public basic_istream<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [istringstream.cons], constructors
     basic_istringstream() : basic_istringstream(ios_base::in) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_istringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in);
+    template<class T>
+      explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in);
+    template<class T>
+      basic_istringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
     basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated storage. For the sake of exposition, the maintained data is
 presented here as:
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="istringstream.cons">[[istringstream.cons]]</a>
 ``` cpp
 explicit basic_istringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 basic_istringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_istringstream(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which = ios_base::in);
 ```
+*Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`
 [[stringbuf.cons]].
+``` cpp
+template<class T>
+  explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in);
+template<class T>
+  basic_istringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::in` for the overload with no parameter
+`which`, and `a` be `Allocator()` for the overload with no parameter
+`a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which | ios_base::in, a`.
 ``` cpp
 basic_istringstream(basic_istringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
+`basic_istream<charT, traits>::set_rdbuf(addressof(`*`sb`*`))` to
+install the contained `basic_stringbuf`.
 #### Swap <a id="istringstream.swap">[[istringstream.swap]]</a>
 ``` cpp
 void swap(basic_istringstream& rhs);
 template<class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="istringstream.members">[[istringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`
 ### Class template `basic_ostringstream` <a id="ostringstream">[[ostringstream]]</a>
 #### General <a id="ostringstream.general">[[ostringstream.general]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_ostringstream : public basic_ostream<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [ostringstream.cons], constructors
     basic_ostringstream() : basic_ostringstream(ios_base::out) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_ostringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out);
+    template<class T>
+      explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out);
+    template<class T>
+      basic_ostringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
     basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
 The class `basic_ostringstream<charT, traits, Allocator>` supports
 writing objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf` object to control the associated storage. For
 the sake of exposition, the maintained data is presented here as:
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="ostringstream.cons">[[ostringstream.cons]]</a>
 ``` cpp
 explicit basic_ostringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with `basic_stringbuf<charT, traits, Allocator>(which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 basic_ostringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::out, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
 [[stringbuf.cons]].
+``` cpp
+template<class T>
+  explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out);
+template<class T>
+  basic_ostringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::out` for the overload with no parameter
+`which`, and `a` be `Allocator()` for the overload with no parameter
+`a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which | ios_base::out, a`.
 ``` cpp
 basic_ostringstream(basic_ostringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
+`basic_ostream<charT, traits>::set_rdbuf(addressof(`*`sb`*`))` to
+install the contained `basic_stringbuf`.
 #### Swap <a id="ostringstream.swap">[[ostringstream.swap]]</a>
 ``` cpp
 void swap(basic_ostringstream& rhs);
 template<class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="ostringstream.members">[[ostringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`
 ### Class template `basic_stringstream` <a id="stringstream">[[stringstream]]</a>
 #### General <a id="stringstream.general">[[stringstream.general]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_stringstream : public basic_iostream<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringstream.cons], constructors
     basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out | ios_base::in);
+    template<class T>
+      explicit basic_stringstream(const T& t,
+                                  ios_base::openmode which = ios_base::out | ios_base::in);
+    template<class T>
+      basic_stringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
     basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   private:
+    basic_stringbuf<charT, traits, Allocator> sb; // exposition only
   };
 }
 ```
 The class template `basic_stringstream<charT, traits>` supports reading
 `basic_string<charT, traits, Allocator>`. It uses a
 `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(which)`.
 ``` cpp
 explicit basic_stringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which)`.
 ``` cpp
 basic_stringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(which, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_stringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_stringstream(
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which)`
 [[stringbuf.cons]].
+``` cpp
+template<class T>
+  explicit basic_stringstream(const T& t, ios_base::openmode which = ios_base::out | ios_base::in);
+template<class T>
+  basic_stringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::out | ios_base::in` for the overload with no
+parameter `which`, and `a` be `Allocator()` for the overload with no
+parameter `a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which, a`.
 ``` cpp
 basic_stringstream(basic_stringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
+`basic_istream<charT, traits>::set_rdbuf(addressof(`*`sb`*`))` to
+install the contained `basic_stringbuf`.
 #### Swap <a id="stringstream.swap">[[stringstream.swap]]</a>
 ``` cpp
 void swap(basic_stringstream& rhs);
 template<class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`

Diff to HTML by rtfpessoa