[string.streams] - C++17 → C++20

Files changed (1) hide show

tmp/tmpolldv5gr/{from.md → to.md} +659 -186

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

@@ -50,26 +50,55 @@ namespace std {
     using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringbuf.cons], constructors
     explicit basic_stringbuf(
       ios_base::openmode which = ios_base::in | ios_base::out);
     explicit basic_stringbuf(
- const basic_string<charT, traits, Allocator>& str,
       ios_base::openmode which = ios_base::in | ios_base::out);
- basic_stringbuf(const basic_stringbuf& rhs) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     // [stringbuf.assign], assign and swap
-    basic_stringbuf& operator=(const basic_stringbuf& rhs) = delete;
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
-    void swap(basic_stringbuf& rhs);
-    // [stringbuf.members], get and set
-    basic_string<charT, traits, Allocator> str() const;
     void str(const 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;
@@ -83,66 +112,120 @@ namespace std {
                      ios_base::openmode which
                       = ios_base::in | ios_base::out) override;
   private:
     ios_base::openmode mode;                        // exposition only
   };
   template<class charT, class traits, class Allocator>
     void swap(basic_stringbuf<charT, traits, Allocator>& x,
-              basic_stringbuf<charT, traits, Allocator>& y);
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
 associate possibly the input sequence and possibly the output sequence
 with a sequence of arbitrary *characters*. The sequence can be
 initialized from, or made available as, an object of class
 `basic_string`.
-For the sake of exposition, the maintained data 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_stringbuf` constructors <a id="stringbuf.cons">[[stringbuf.cons]]</a>
 ``` cpp
-explicit basic_stringbuf(
-  ios_base::openmode which = ios_base::in | ios_base::out);
 ```
-*Effects:* Constructs an object of class `basic_stringbuf`, initializing
-the base class with `basic_streambuf()` ([[streambuf.cons]]), and
-initializing `mode` with `which`.
-*Postconditions:* `str() == ""`.
 ``` cpp
 explicit basic_stringbuf(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
-*Effects:* Constructs an object of class `basic_stringbuf`, initializing
-the base class with `basic_streambuf()` ([[streambuf.cons]]), and
-initializing `mode` with `which`. Then calls `str(s)`.
 ``` cpp
 basic_stringbuf(basic_stringbuf&& rhs);
 ```
-*Effects:* Move constructs from the rvalue `rhs`. It is
-*implementation-defined* whether the sequence pointers in `*this`
-(`eback()`, `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) obtain
-the values which `rhs` had. Whether they do or not, `*this` and `rhs`
-reference separate buffers (if any at all) after the construction. The
-openmode, locale and any other state of `rhs` is also copied.
-*Postconditions:* Let `rhs_p` refer to the state of `rhs` just prior to
-this construction and let `rhs_a` refer to the state of `rhs` just after
-this construction.
 - `str() == rhs_p.str()`
 - `gptr() - eback() == rhs_p.gptr() - rhs_p.eback()`
 - `egptr() - eback() == rhs_p.egptr() - rhs_p.eback()`
 - `pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()`
@@ -151,12 +234,14 @@ this construction.
 - `if (gptr()) gptr() != rhs_a.gptr()`
 - `if (egptr()) egptr() != rhs_a.egptr()`
 - `if (pbase()) pbase() != rhs_a.pbase()`
 - `if (pptr()) pptr() != rhs_a.pptr()`
 - `if (epptr()) epptr() != rhs_a.epptr()`
-#### Assign and swap <a id="stringbuf.assign">[[stringbuf.assign]]</a>
 ``` cpp
 basic_stringbuf& operator=(basic_stringbuf&& rhs);
 ```
@@ -165,62 +250,165 @@ would have had if it had been move constructed from `rhs`
 (see  [[stringbuf.cons]]).
 *Returns:* `*this`.
 ``` cpp
-void swap(basic_stringbuf& rhs);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
-            basic_stringbuf<charT, traits, Allocator>& y);
 ```
-*Effects:* As if by `x.swap(y)`.
 #### Member functions <a id="stringbuf.members">[[stringbuf.members]]</a>
 ``` cpp
-basic_string<charT, traits, Allocator> str() const;
-```
-*Returns:* A `basic_string` object whose content is equal to the
-`basic_stringbuf` underlying character sequence. If the
-`basic_stringbuf` was created only in input mode, the resultant
-`basic_string` contains the character sequence in the range \[`eback()`,
-`egptr()`). If the `basic_stringbuf` was created with
-`which & ios_base::out` being nonzero then the resultant `basic_string`
-contains the character sequence in the range \[`pbase()`, `high_mark`),
-where `high_mark` represents the position one past the highest
-initialized character in the buffer. Characters can be initialized by
-writing to the stream, by constructing the `basic_stringbuf` with a
-`basic_string`, or by calling the `str(basic_string)` member function.
-In the case of calling the `str(basic_string)` member function, all
-characters initialized prior to the call are now considered
-uninitialized (except for those characters re-initialized by the new
-`basic_string`). Otherwise the `basic_stringbuf` has been created in
-neither input nor output mode and a zero length `basic_string` is
-returned.
 ``` cpp
 void str(const basic_string<charT, traits, Allocator>& s);
 ```
-*Effects:* Copies the content of `s` into the `basic_stringbuf`
-underlying character sequence and initializes the input and output
-sequences according to `mode`.
-*Postconditions:* If `mode & ios_base::out` is nonzero, `pbase()` points
-to the first underlying character and `epptr()` `>= pbase() + s.size()`
-holds; in addition, if `mode & ios_base::ate` is nonzero,
-`pptr() == pbase() + s.size()` holds, otherwise `pptr() == pbase()` is
-`true`. If `mode & ios_base::in` is nonzero, `eback()` points to the
-first underlying character, and both `gptr() == eback()` and
-`egptr() == eback() + s.size()` hold.
 #### Overridden virtual functions <a id="stringbuf.virtuals">[[stringbuf.virtuals]]</a>
 ``` cpp
 int_type underflow() override;
@@ -247,11 +435,11 @@ sequence, if possible, in one of three ways:
   `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)`.
-*Returns:* `traits::eof()` to indicate failure.
 *Remarks:* If the function can succeed in more than one of these ways,
 it is unspecified which way is chosen.
 ``` cpp
@@ -270,56 +458,55 @@ sequence, if possible, in one of two ways:
   `traits::eof()`.
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
-*Returns:* `traits::eof()` to indicate failure.
-The function can make a write position available only if
-`(mode & ios_base::out) != 0`. 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
-`(mode & ios_base::in) != 0`, 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,
                  ios_base::openmode which
                    = ios_base::in | ios_base::out) override;
 ```
 *Effects:* Alters the stream position within one of the controlled
-sequences, if possible, as indicated in
-Table  [[tab:iostreams.seekoff.positioning]].
-**Table: `seekoff` positioning** <a id="tab:iostreams.seekoff.positioning">[tab:iostreams.seekoff.positioning]</a>
 | Conditions                                                                                                                     | Result                                            |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- |
-| `(which & ios_base::in)`` == ios_base::in` | positions the input sequence                      |
-| `(which & ios_base::out)`` == ios_base::out` | positions the output sequence                     |
-| `(which & (ios_base::in |`<br> `ios_base::out)) ==`<br> `(ios_base::in) |`<br> `ios_base::out))`<br> and `way ==` either<br> `ios_base::beg` or<br> `ios_base::end` | positions both the input and the output sequences |
 | Otherwise                                                                                                                      | the positioning operation fails.                  |
-For a sequence to be positioned, if its next pointer (either `gptr()` or
-`pptr()`) is a null pointer and the new offset `newoff` is nonzero, the
-positioning operation fails. Otherwise, the function determines `newoff`
-as indicated in Table  [[tab:iostreams.newoff.values]].
-**Table: `newoff` values** <a id="tab:iostreams.newoff.values">[tab:iostreams.newoff.values]</a>
 | Condition              | `newoff` Value                                                          |
 | ---------------------- | ----------------------------------------------------------------------- |
 | `way == ios_base::beg` | 0                                                                       |
 | `way == ios_base::cur` | the next pointer minus the beginning pointer (`xnext - xbeg`).          |
 | `way == ios_base::end` | the high mark pointer minus the beginning pointer (`high_mark - xbeg`). |
 If `(newoff + off) < 0`, or if `newoff + off` refers to an uninitialized
-character ([[stringbuf.members]]), the positioning operation fails.
 Otherwise, the function assigns `xbeg + newoff + off` to the next
 pointer `xnext`.
 *Returns:* `pos_type(newoff)`, constructed from the resultant offset
 `newoff` (of type `off_type`), that stores the resultant stream
@@ -361,28 +548,52 @@ namespace std {
     using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [istringstream.cons], constructors
     explicit basic_istringstream(
       ios_base::openmode which = ios_base::in);
     explicit basic_istringstream(
- const basic_string<charT, traits, Allocator>& str,
       ios_base::openmode which = ios_base::in);
- basic_istringstream(const basic_istringstream& rhs) = delete;
     basic_istringstream(basic_istringstream&& rhs);
     // [istringstream.assign], assign and swap
-    basic_istringstream& operator=(const basic_istringstream& rhs) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
     // [istringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
-    basic_string<charT, traits, Allocator> str() const;
     void str(const basic_string<charT, traits, Allocator>& s);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
   template<class charT, class traits, class Allocator>
@@ -397,87 +608,157 @@ 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.
-#### `basic_istringstream` constructors <a id="istringstream.cons">[[istringstream.cons]]</a>
 ``` cpp
-explicit basic_istringstream(ios_base::openmode which = ios_base::in);
 ```
-*Effects:* Constructs an object of class
-`basic_istringstream<charT, traits>`, initializing the base class with
-`basic_istream(&sb)` and initializing `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::in))` ([[stringbuf.cons]]).
 ``` cpp
 explicit basic_istringstream(
-  const basic_string<charT, traits, Allocator>& str,
   ios_base::openmode which = ios_base::in);
 ```
-*Effects:* Constructs an object of class
-`basic_istringstream<charT, traits>`, initializing the base class with
-`basic_istream(&sb)` and initializing `sb` with
-`basic_stringbuf<charT, traits, Allocator>(str, 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`. Next `basic_istream<charT, traits>::set_rdbuf(&sb)`
-is called to install the contained `basic_stringbuf`.
-#### Assign and swap <a id="istringstream.assign">[[istringstream.assign]]</a>
-``` cpp
-basic_istringstream& operator=(basic_istringstream&& rhs);
-```
-*Effects:* Move assigns the base and members of `*this` from the base
-and corresponding members of `rhs`.
-*Returns:* `*this`.
 ``` cpp
 void swap(basic_istringstream& rhs);
 ```
-*Effects:* Exchanges the state of `*this` and `rhs` by calling
-`basic_istream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* As if by `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>*>(&sb)`.
 ``` cpp
-basic_string<charT, traits, Allocator> str() const;
 ```
-*Returns:* `rdbuf()->str()`.
 ``` cpp
 void str(const basic_string<charT, traits, Allocator>& s);
 ```
-*Effects:* Calls `rdbuf()->str(s)`.
 ### Class template `basic_ostringstream` <a id="ostringstream">[[ostringstream]]</a>
 ``` cpp
 namespace std {
@@ -491,28 +772,53 @@ namespace std {
     using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [ostringstream.cons], constructors
     explicit basic_ostringstream(
       ios_base::openmode which = ios_base::out);
     explicit basic_ostringstream(
- const basic_string<charT, traits, Allocator>& str,
       ios_base::openmode which = ios_base::out);
- basic_ostringstream(const basic_ostringstream& rhs) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
     // [ostringstream.assign], assign and swap
-    basic_ostringstream& operator=(const basic_ostringstream& rhs) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
     // [ostringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
-    basic_string<charT, traits, Allocator> str() const;
     void str(const basic_string<charT, traits, Allocator>& s);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
   template<class charT, class traits, class Allocator>
@@ -526,88 +832,157 @@ 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.
-#### `basic_ostringstream` constructors <a id="ostringstream.cons">[[ostringstream.cons]]</a>
 ``` cpp
 explicit basic_ostringstream(
   ios_base::openmode which = ios_base::out);
 ```
-*Effects:* Constructs an object of class `basic_ostringstream`,
-initializing the base class with `basic_ostream(&sb)` and initializing
-`sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::out))` ([[stringbuf.cons]]).
 ``` cpp
 explicit basic_ostringstream(
- const basic_string<charT, traits, Allocator>& str,
   ios_base::openmode which = ios_base::out);
 ```
-*Effects:* Constructs an object of class
-`basic_ostringstream<charT, traits>`, initializing the base class with
-`basic_ostream(&sb)` and initializing `sb` with
-`basic_stringbuf<charT, traits, Allocator>(str, 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`. Next `basic_ostream<charT, traits>::set_rdbuf(&sb)`
-is called to install the contained `basic_stringbuf`.
-#### Assign and swap <a id="ostringstream.assign">[[ostringstream.assign]]</a>
-``` cpp
-basic_ostringstream& operator=(basic_ostringstream&& rhs);
-```
-*Effects:* Move assigns the base and members of `*this` from the base
-and corresponding members of `rhs`.
-*Returns:* `*this`.
 ``` cpp
 void swap(basic_ostringstream& rhs);
 ```
-*Effects:* Exchanges the state of `*this` and `rhs` by calling
-`basic_ostream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* As if by `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>*>(&sb)`.
 ``` cpp
-basic_string<charT, traits, Allocator> str() const;
 ```
-*Returns:* `rdbuf()->str()`.
 ``` cpp
 void str(const basic_string<charT, traits, Allocator>& s);
 ```
-*Effects:* Calls `rdbuf()->str(s)`.
 ### Class template `basic_stringstream` <a id="stringstream">[[stringstream]]</a>
 ``` cpp
 namespace std {
@@ -621,27 +996,52 @@ namespace std {
     using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringstream.cons], constructors
     explicit basic_stringstream(
       ios_base::openmode which = ios_base::out | ios_base::in);
     explicit basic_stringstream(
- const basic_string<charT, traits, Allocator>& str,
       ios_base::openmode which = ios_base::out | ios_base::in);
- basic_stringstream(const basic_stringstream& rhs) = delete;
     basic_stringstream(basic_stringstream&& rhs);
     // [stringstream.assign], assign and swap
-    basic_stringstream& operator=(const basic_stringstream& rhs) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
     // [stringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
-    basic_string<charT, traits, Allocator> str() const;
- void str(const basic_string<charT, traits, Allocator>& str);
   private:
     basic_stringbuf<charT, traits> sb;  // exposition only
   };
@@ -658,83 +1058,156 @@ and writing from objects of class
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
 - `sb`, the `stringbuf` object.
-#### `basic_stringstream` constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
-*Effects:* Constructs an object of class
-`basic_stringstream<charT, traits>`, initializing the base class with
-`basic_iostream(&sb)` and initializing `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which)`.
 ``` cpp
 explicit basic_stringstream(
- const basic_string<charT, traits, Allocator>& str,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
-*Effects:* Constructs an object of class
-`basic_stringstream<charT, traits>`, initializing the base class with
-`basic_iostream(&sb)` and initializing `sb` with
-`basic_stringbuf<charT, traits, Allocator>(str, which)`.
 ``` 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`. Next `basic_istream<charT, traits>::set_rdbuf(&sb)`
-is called to install the contained `basic_stringbuf`.
-#### Assign and swap <a id="stringstream.assign">[[stringstream.assign]]</a>
-``` cpp
-basic_stringstream& operator=(basic_stringstream&& rhs);
-```
-*Effects:* Move assigns the base and members of `*this` from the base
-and corresponding members of `rhs`.
-*Returns:* `*this`.
 ``` cpp
 void swap(basic_stringstream& rhs);
 ```
-*Effects:* Exchanges the state of `*this` and `rhs` by calling
-`basic_iostream<charT,traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* As if by `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>*>(&sb)`
 ``` cpp
-basic_string<charT, traits, Allocator> str() const;
 ```
-*Returns:* `rdbuf()->str()`.
 ``` cpp
-void str(const basic_string<charT, traits, Allocator>& str);
 ```
-*Effects:* Calls `rdbuf()->str(str)`.

     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) {}
+    explicit basic_stringbuf(ios_base::openmode which);
     explicit basic_stringbuf(
+      const basic_string<charT, traits, Allocator>& s,
       ios_base::openmode which = ios_base::in | ios_base::out);
+    explicit basic_stringbuf(const Allocator& a)
+      : basic_stringbuf(ios_base::in | ios_base::out, a) {}
+    basic_stringbuf(ios_base::openmode which, const Allocator& a);
     explicit basic_stringbuf(
+      basic_string<charT, traits, Allocator>&& s,
       ios_base::openmode which = ios_base::in | ios_base::out);
+ template<class SAlloc>
+      basic_stringbuf(
+        const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+        : basic_stringbuf(s, ios_base::in | ios_base::out, a) {}
+    template<class SAlloc>
+      basic_stringbuf(
+        const basic_string<charT, traits, SAlloc>& s,
+        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], assign and swap
+    basic_stringbuf& operator=(const basic_stringbuf&) = delete;
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
+    void swap(basic_stringbuf& rhs) noexcept(see below);
+    // [stringbuf.members], getters and setters
+    allocator_type get_allocator() const noexcept;
+    basic_string<charT, traits, Allocator> str() const &;
+    template<class SAlloc>
+      basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+    basic_string<charT, traits, Allocator> str() &&;
+    basic_string_view<charT, traits> view() const noexcept;
     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;
                      ios_base::openmode which
                       = 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
   };
   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)));
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
 associate possibly the input sequence and possibly the output sequence
 with a sequence of arbitrary *characters*. The sequence can be
 initialized from, or made available as, an object of class
 `basic_string`.
+For the sake of exposition, the maintained data and internal pointer
+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`.
 ``` cpp
 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,
+    ios_base::openmode which = ios_base::in | ios_base::out);
+```
+*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
+construction and let `rhs_a` refer to the state of `rhs` just after this
+construction.
 - `str() == rhs_p.str()`
 - `gptr() - eback() == rhs_p.gptr() - rhs_p.eback()`
 - `egptr() - eback() == rhs_p.egptr() - rhs_p.eback()`
 - `pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()`
 - `if (gptr()) gptr() != rhs_a.gptr()`
 - `if (egptr()) egptr() != rhs_a.egptr()`
 - `if (pbase()) pbase() != rhs_a.pbase()`
 - `if (pptr()) pptr() != rhs_a.pptr()`
 - `if (epptr()) epptr() != rhs_a.epptr()`
+- `getloc() == rhs_p.getloc()`
+- `rhs` is empty but usable, as if `std::move(rhs).str()` was called.
+#### Assignment and swap <a id="stringbuf.assign">[[stringbuf.assign]]</a>
 ``` cpp
 basic_stringbuf& operator=(basic_stringbuf&& rhs);
 ```
 (see  [[stringbuf.cons]]).
 *Returns:* `*this`.
 ``` cpp
+void swap(basic_stringbuf& rhs) noexcept(see below);
 ```
+*Preconditions:*
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true` or `get_allocator() == s.get_allocator()` is `true`.
 *Effects:* Exchanges the state of `*this` and `rhs`.
+*Remarks:* The expression inside `noexcept` 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
+past the highest initialized character in the buffer. Characters can be
+initialized by writing to the stream, by constructing the
+`basic_stringbuf` passing a `basic_string` argument, or by calling one
+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 might
+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 &;
+```
+*Effects:* Equivalent to:
+``` cpp
+return basic_string<charT, traits, Allocator>(view(), get_allocator());
+```
 ``` cpp
+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);
+```
+``` cpp
+basic_string<charT, traits, Allocator> str() &&;
+```
+*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()`.
+*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`.
+``` cpp
+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
+behavior, unless `sv.empty()` is `true`. — *end note*]
 ``` cpp
 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);
+```
+*Constraints:* `is_same_v<SAlloc,Allocator>` is `false`.
+*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
 int_type underflow() override;
   `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)`.
+*Returns:* As specified above, or `traits::eof()` to indicate failure.
 *Remarks:* If the function can succeed in more than one of these ways,
 it is unspecified which way is chosen.
 ``` cpp
   `traits::eof()`.
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
+*Returns:* As specified above, or `traits::eof()` to indicate failure.
+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,
                  ios_base::openmode which
                    = ios_base::in | ios_base::out) override;
 ```
 *Effects:* Alters the stream position within one of the controlled
+sequences, if possible, as indicated in [[stringbuf.seekoff.pos]].
+**Table: `seekoff` positioning** <a id="stringbuf.seekoff.pos">[stringbuf.seekoff.pos]</a>
 | Conditions                                                                                                                     | Result                                            |
+| ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------- |
+| `ios_base::in` is set in `which`                                                                                               | positions the input sequence                      |
+| `ios_base::out` is set in `which`                                                                                              | positions the output sequence                     |
+| both `ios_base::in` and `ios_base::out` are set in `which` and either<br> `way == ios_base::beg` or<br> `way == ios_base::end` | positions both the input and the output sequences |
 | Otherwise                                                                                                                      | the positioning operation fails.                  |
+For a sequence to be positioned, the function determines `newoff` as
+indicated in [[stringbuf.seekoff.newoff]]. If the sequence’s next
+pointer (either `gptr()` or `pptr()`) is a null pointer and `newoff` is
+nonzero, the positioning operation fails.
+**Table: `newoff` values** <a id="stringbuf.seekoff.newoff">[stringbuf.seekoff.newoff]</a>
 | Condition              | `newoff` Value                                                          |
 | ---------------------- | ----------------------------------------------------------------------- |
 | `way == ios_base::beg` | 0                                                                       |
 | `way == ios_base::cur` | the next pointer minus the beginning pointer (`xnext - xbeg`).          |
 | `way == ios_base::end` | the high mark pointer minus the beginning pointer (`high_mark - xbeg`). |
 If `(newoff + off) < 0`, or if `newoff + off` refers to an uninitialized
+character [[stringbuf.members]], the positioning operation fails.
 Otherwise, the function assigns `xbeg + newoff + off` to the next
 pointer `xnext`.
 *Returns:* `pos_type(newoff)`, constructed from the resultant offset
 `newoff` (of type `off_type`), that stores the resultant stream
     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) {}
+    explicit basic_istringstream(ios_base::openmode which);
     explicit basic_istringstream(
+      const basic_string<charT, traits, Allocator>& s,
       ios_base::openmode which = ios_base::in);
+    basic_istringstream(ios_base::openmode which, const Allocator& a);
     explicit basic_istringstream(
+      basic_string<charT, traits, Allocator>&& s,
       ios_base::openmode which = ios_base::in);
+ template<class SAlloc>
+      basic_istringstream(
+        const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+        : basic_istringstream(s, ios_base::in, a) {}
+    template<class SAlloc>
+      basic_istringstream(
+        const basic_string<charT, traits, SAlloc>& s,
+        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);
     // [istringstream.assign], assign and swap
+    basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
     // [istringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
+    basic_string<charT, traits, Allocator> str() const &;
+    template<class SAlloc>
+      basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+    basic_string<charT, traits, Allocator> str() &&;
+    basic_string_view<charT, traits> view() const noexcept;
     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
   };
   template<class charT, class traits, class Allocator>
 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>
+  basic_istringstream(
+    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`.
+#### Assignment and swap <a id="istringstream.assign">[[istringstream.assign]]</a>
 ``` cpp
 void swap(basic_istringstream& rhs);
 ```
+*Effects:* Equivalent to:
+``` cpp
+basic_istream<charT, traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
 ``` cpp
 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 &;
 ```
+*Effects:* Equivalent to: `return rdbuf()->str();`
+``` cpp
+template<class SAlloc>
+  basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+```
+*Effects:* Equivalent to: `return rdbuf()->str(sa);`
+``` cpp
+basic_string<charT,traits,Allocator> str() &&;
+```
+*Effects:* Equivalent to: `return std::move(*rdbuf()).str();`
+``` cpp
+basic_string_view<charT, traits> view() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->view();`
 ``` cpp
 void str(const basic_string<charT, traits, Allocator>& s);
 ```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+template<class SAlloc>
+  void str(const basic_string<charT, traits, SAlloc>& s);
+```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+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>
 ``` cpp
 namespace std {
     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) {}
+    explicit basic_ostringstream(ios_base::openmode which);
     explicit basic_ostringstream(
+      const basic_string<charT, traits, Allocator>& s,
       ios_base::openmode which = ios_base::out);
+    basic_ostringstream(ios_base::openmode which, const Allocator& a);
     explicit basic_ostringstream(
+      basic_string<charT, traits, Allocator>&& s,
       ios_base::openmode which = ios_base::out);
+ template<class SAlloc>
+      basic_ostringstream(
+        const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+        : basic_ostringstream(s, ios_base::out, a) {}
+    template<class SAlloc>
+      basic_ostringstream(
+        const basic_string<charT, traits, SAlloc>& s,
+        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);
     // [ostringstream.assign], assign and swap
+    basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
     // [ostringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
+    basic_string<charT, traits, Allocator> str() const &;
+    template<class SAlloc>
+      basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+    basic_string<charT, traits, Allocator> str() &&;
+    basic_string_view<charT, traits> view() const noexcept;
     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
   };
   template<class charT, class traits, class Allocator>
 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>
+  basic_ostringstream(
+    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>
+  explicit basic_ostringstream(
+    const basic_string<charT, traits, SAlloc>& s,
+    ios_base::openmode which = ios_base::out);
+```
+*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`.
+#### Assignment and swap <a id="ostringstream.assign">[[ostringstream.assign]]</a>
 ``` cpp
 void swap(basic_ostringstream& rhs);
 ```
+*Effects:* Equivalent to:
+``` cpp
+basic_ostream<charT, traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
 ``` cpp
 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 &;
 ```
+*Effects:* Equivalent to: `return rdbuf()->str();`
+``` cpp
+template<class SAlloc>
+  basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+```
+*Effects:* Equivalent to: `return rdbuf()->str(sa);`
+``` cpp
+basic_string<charT,traits,Allocator> str() &&;
+```
+*Effects:* Equivalent to: `return std::move(*rdbuf()).str();`
+``` cpp
+basic_string_view<charT, traits> view() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->view();`
 ``` cpp
 void str(const basic_string<charT, traits, Allocator>& s);
 ```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+template<class SAlloc>
+  void str(const basic_string<charT, traits, SAlloc>& s);
+```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+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>
 ``` cpp
 namespace std {
     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) {}
+    explicit basic_stringstream(ios_base::openmode which);
     explicit basic_stringstream(
+      const basic_string<charT, traits, Allocator>& s,
       ios_base::openmode which = ios_base::out | ios_base::in);
+    basic_stringstream(ios_base::openmode which, const Allocator& a);
     explicit basic_stringstream(
+      basic_string<charT, traits, Allocator>&& s,
       ios_base::openmode which = ios_base::out | ios_base::in);
+ template<class SAlloc>
+      basic_stringstream(
+        const basic_string<charT, traits, SAlloc>& s, const Allocator& a)
+        : basic_stringstream(s, ios_base::out | ios_base::in, a) {}
+    template<class SAlloc>
+      basic_stringstream(
+        const basic_string<charT, traits, SAlloc>& s,
+        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);
     // [stringstream.assign], assign and swap
+    basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
     // [stringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
+    basic_string<charT, traits, Allocator> str() const &;
+    template<class SAlloc>
+      basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
+    basic_string<charT, traits, Allocator> str() &&;
+    basic_string_view<charT, traits> view() const noexcept;
+    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
   };
 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>
+  basic_stringstream(
+    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(
+    const basic_string<charT, traits, SAlloc>& s,
+    ios_base::openmode which = ios_base::out | ios_base::in);
+```
+*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`.
+#### Assignment and swap <a id="stringstream.assign">[[stringstream.assign]]</a>
 ``` cpp
 void swap(basic_stringstream& rhs);
 ```
+*Effects:* Equivalent to:
+``` cpp
+basic_iostream<charT,traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
 ``` cpp
 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 &;
 ```
+*Effects:* Equivalent to: `return rdbuf()->str();`
 ``` cpp
+template<class SAlloc>
+  basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
 ```
+*Effects:* Equivalent to: `return rdbuf()->str(sa);`
+``` cpp
+basic_string<charT,traits,Allocator> str() &&;
+```
+*Effects:* Equivalent to: `return std::move(*rdbuf()).str();`
+``` cpp
+basic_string_view<charT, traits> view() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->view();`
+``` cpp
+void str(const basic_string<charT, traits, Allocator>& s);
+```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+template<class SAlloc>
+  void str(const basic_string<charT, traits, SAlloc>& s);
+```
+*Effects:* Equivalent to: `rdbuf()->str(s);`
+``` cpp
+void str(basic_string<charT, traits, Allocator>&& s);
+```
+*Effects:* Equivalent to: `rdbuf()->str(std::move(s));`

Diff to HTML by rtfpessoa