[iostream.format] - C++20 → C++23

Files changed (1) hide show

tmp/tmpgddwfx70/{from.md → to.md} +654 -323

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

@@ -17,12 +17,12 @@ namespace std {
   using wiostream = basic_iostream<wchar_t>;
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
-  template<class charT, class traits, class T>
- basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
@@ -46,56 +46,96 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
-  template<class charT, class traits, class T>
- basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
- // types T1, T2, ... are unspecified implementation types
- T1 resetiosflags(ios_base::fmtflags mask);
- T2 setiosflags  (ios_base::fmtflags mask);
- T3 setbase(int base);
- template<class charT> T4 setfill(charT c);
- T5 setprecision(int n);
- T6 setw(int n);
-  template<class moneyT> T7 get_money(moneyT& mon, bool intl = false);
-  template<class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
-  template<class charT> T9 get_time(struct tm* tmb, const charT* fmt);
-  template<class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
   template<class charT>
- T11 quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
- T12 quoted(const basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
- T13 quoted(basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits>
- T14 quoted(basic_string_view<charT, traits> s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
-The header `<istream>` defines two types and a function signature that
-control input from a stream buffer along with a function template that
-extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
@@ -112,64 +152,62 @@ namespace std {
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
-    basic_istream<charT, traits>&
- operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(ios_base& (*pf)(ios_base&));
-    basic_istream<charT, traits>& operator>>(bool& n);
-    basic_istream<charT, traits>& operator>>(short& n);
-    basic_istream<charT, traits>& operator>>(unsigned short& n);
-    basic_istream<charT, traits>& operator>>(int& n);
-    basic_istream<charT, traits>& operator>>(unsigned int& n);
-    basic_istream<charT, traits>& operator>>(long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long& n);
-    basic_istream<charT, traits>& operator>>(long long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long long& n);
-    basic_istream<charT, traits>& operator>>(float& f);
-    basic_istream<charT, traits>& operator>>(double& f);
-    basic_istream<charT, traits>& operator>>(long double& f);
-    basic_istream<charT, traits>& operator>>(void*& p);
-    basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
-    basic_istream<charT, traits>& get(char_type& c);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
-    basic_istream<charT, traits>& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
-    basic_istream<charT, traits>& putback(char_type c);
-    basic_istream<charT, traits>& unget();
     int sync();
     pos_type tellg();
-    basic_istream<charT, traits>& seekg(pos_type);
-    basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
-    // [istream.assign], assign and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
@@ -198,22 +236,10 @@ Two groups of member function signatures share common properties: the
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
-If `rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`,
-then the input function, except as explicitly noted otherwise, completes
-its actions and does `setstate(eofbit)`, which may throw
-`ios_base::failure` [[iostate.flags]], before returning.
-If one of these called functions throws an exception, then unless
-explicitly noted otherwise, the input function sets `badbit` in the
-error state. If `badbit` is set in `exceptions()`, the input function
-rethrows the exception without completing its actions, otherwise it does
-not throw anything and proceeds as if the called function had returned a
-failure indication.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
@@ -256,15 +282,16 @@ values returned by `gcount()` and `rhs.gcount()`.
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
-    explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
   };
@@ -273,32 +300,34 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
-explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
 ```
 *Effects:* If `is.good()` is `false`, calls `is.setstate(failbit)`.
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
-`flush` may be eliminated entirely.[^18] If `noskipws` is zero and
-`is.flags() & ios_base::skipws` is nonzero, the function extracts and
-discards each character as long as the next available input character
-`c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
-`is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
-`setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
 *Remarks:* The constructor
 ``` cpp
-explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
@@ -331,47 +360,56 @@ explicit operator bool() const;
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
-of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
-`bool`, the function endeavors to obtain the requested input. If an
-exception is thrown during input then `ios_base::badbit` is turned
-on[^20] in `*this`’s error state. If `(exceptions()&badbit) != 0` then
-the exception is rethrown. In any case, the formatted input function
-destroys the `sentry` object. If no exception has been thrown, it
-returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
-operator>>(unsigned short& val);
-operator>>(unsigned int& val);
-operator>>(long& val);
-operator>>(unsigned long& val);
-operator>>(long long& val);
-operator>>(unsigned long long& val);
-operator>>(float& val);
-operator>>(double& val);
-operator>>(long double& val);
-operator>>(bool& val);
-operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
-described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
-fragment:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = iostate::goodbit;
-use_facet<numget>(loc).get(*this, 0, *this, err, val);
-setstate(err);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
@@ -382,85 +420,123 @@ directly. — *end note*]
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
-operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<short>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
-setstate(err);
 ```
 ``` cpp
-operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<int>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
-setstate(err);
 ```
 ##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
-basic_istream<charT, traits>&
-  operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^21]
 ``` cpp
-basic_istream<charT, traits>&
-  operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(ios_base& (*pf)(ios_base&));
 ```
-*Effects:* Calls `pf(*this)`.[^22] This extractor does not behave as a
-formatted input function (as described
-in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
 template<class charT, class traits, size_t N>
@@ -486,12 +562,12 @@ Characters are extracted and stored until any of the following occurs:
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
-If the function extracted no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
@@ -501,132 +577,138 @@ template<class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
-in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
-constructed a character is extracted from `in`, if one is available, and
-stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 *Returns:* `in`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
-[[iostate.flags]]. After a sentry object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]]. If it inserted no
-characters because it caught an exception thrown while extracting
-characters from `*this` and `failbit` is set in `exceptions()`
-[[iostate.flags]], then the caught exception is rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
-object of class `sentry` with the default argument `noskipws` (second)
-argument `true`. If the `sentry` object returns `true`, when converted
-to a value of type `bool`, the function endeavors to obtain the
-requested input. Otherwise, if the sentry constructor exits by throwing
-an exception or if the sentry object returns `false`, when converted to
-a value of type `bool`, the function returns without attempting to
-obtain any input. In either case the number of extracted characters is
-set to 0; unformatted input functions taking a character array of
-nonzero size as an argument shall also store a null character (using
-`charT()`) in the first location of the array. If an exception is thrown
-during input then `ios_base::badbit` is turned on[^23] in `*this`’s
-error state. (Exceptions thrown from `basic_ios<>::clear()` are not
-caught or rethrown.) If `(exceptions()&badbit) != 0` then the exception
-is rethrown. It also counts the number of characters extracted. If no
-exception has been thrown it ends by storing the count in a member
-object and returning the value specified. In any event the `sentry`
-object is destroyed before leaving the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
-input member function called for the object.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character `c`, if
-one is available. Otherwise, the function calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character, if one
-is available, and assigns it to `c`.[^24] Otherwise, the function calls
-`setstate(failbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 stores them into successive locations of an array whose first element is
-designated by `s`.[^25] Characters are extracted and stored until any of
-the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
-- end-of-file occurs on the input sequence (in which case the function
-  calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
-If the function stores no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]). In any case, if
-`n` is greater than zero it then stores a null character into the next
-successive location of the array.
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
@@ -634,45 +716,45 @@ extracted and inserted until any of the following occurs:
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 stores them into successive locations of an array whose first element is
-designated by `s`.[^26] Characters are extracted and stored until one of
-the following occurs:
-1.  end-of-file occurs on the input sequence (in which case the function
-    calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
-    stored);[^27]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
-These conditions are tested in the order shown.[^28]
-If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]).[^29]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
@@ -706,21 +788,21 @@ int main() {
 ```
 — *end example*]
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
-basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
@@ -728,36 +810,38 @@ occurs:
   calls `setstate(eofbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]);
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
-*Remarks:* The last condition will never occur if
-`traits::eq_int_type(delim, traits::eof())`.
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
-basic_istream<charT, traits>& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
-array whose first element is designated by `s`.[^30] Characters are
-extracted and stored until either of the following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
   `ios_base::failure` [[iostate.flags]]).
@@ -767,11 +851,11 @@ extracted and stored until either of the following occurs:
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
@@ -780,51 +864,51 @@ array whose first element is designated by `s`. If
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
-basic_istream<charT, traits>& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
-[*Note 1*: This function extracts no characters, so the value returned
-by the next call to `gcount()` is 0. — *end note*]
-*Returns:* `*this`.
-``` cpp
-basic_istream<charT, traits>& unget();
-```
-*Effects:* Behaves as an unformatted input function (as described
-above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
-which may throw an exception, and return. If `rdbuf()` is not null,
-calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
-returns `traits::eof()`, calls `setstate(badbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
-`gcount()`. After constructing a sentry object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
@@ -835,38 +919,38 @@ pos_type tellg();
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
-*Returns:* After constructing a sentry object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
-basic_istream<charT, traits>& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
-sentry object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
-returned by subsequent calls to `gcount()`. After constructing a sentry
-object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
@@ -882,11 +966,11 @@ template<class charT, class traits>
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
-subsequent calls to `is.gcount()`. After constructing a sentry object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
@@ -900,22 +984,24 @@ characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
-when treated as an unevaluated operand and `Istream` is publicly and
-unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
@@ -936,11 +1022,11 @@ namespace std {
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
-    // [iostream.assign], assign and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
@@ -965,11 +1051,11 @@ explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
-`basic_istream` base class with `move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
@@ -991,16 +1077,24 @@ void swap(basic_iostream& rhs);
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
 ### Output streams <a id="output.streams">[[output.streams]]</a>
-The header `<ostream>` defines a type and several function signatures
-that control output to a stream buffer along with a function template
-that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
@@ -1017,51 +1111,50 @@ namespace std {
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
-    basic_ostream<charT, traits>&
- operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(ios_base& (*pf)(ios_base&));
-    basic_ostream<charT, traits>& operator<<(bool n);
-    basic_ostream<charT, traits>& operator<<(short n);
-    basic_ostream<charT, traits>& operator<<(unsigned short n);
-    basic_ostream<charT, traits>& operator<<(int n);
-    basic_ostream<charT, traits>& operator<<(unsigned int n);
-    basic_ostream<charT, traits>& operator<<(long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long n);
-    basic_ostream<charT, traits>& operator<<(long long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long long n);
-    basic_ostream<charT, traits>& operator<<(float f);
-    basic_ostream<charT, traits>& operator<<(double f);
-    basic_ostream<charT, traits>& operator<<(long double f);
-    basic_ostream<charT, traits>& operator<<(const void* p);
-    basic_ostream<charT, traits>& operator<<(nullptr_t);
-    basic_ostream<charT, traits>& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
-    basic_ostream<charT, traits>& put(char_type c);
-    basic_ostream<charT, traits>& write(const char_type* s, streamsize n);
-    basic_ostream<charT, traits>& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
-    basic_ostream<charT, traits>& seekp(pos_type);
-    basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
-    // [ostream.assign], assign and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
@@ -1197,15 +1290,16 @@ void swap(basic_ostream& rhs);
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
-    explicit sentry(basic_ostream<charT, traits>& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
@@ -1215,20 +1309,20 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
-explicit sentry(basic_ostream<charT, traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
-If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^31]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).[^32]
 ``` cpp
 ~sentry();
 ```
@@ -1254,22 +1348,22 @@ pos_type tellp();
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
@@ -1280,20 +1374,22 @@ function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
-function does `setstate(ios_base::failbit)`, which might throw an
 exception. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^33] in `*this`’s error state. If
-`(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
-not an exception is thrown, the `sentry` object is destroyed before
-leaving the formatted output function. If no exception is thrown, the
-result of the formatted output function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
@@ -1306,23 +1402,23 @@ the fill characters are placed after the character sequence; otherwise,
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
-operator<<(bool val);
-operator<<(short val);
-operator<<(unsigned short val);
-operator<<(int val);
-operator<<(unsigned int val);
-operator<<(long val);
-operator<<(unsigned long val);
-operator<<(long long val);
-operator<<(unsigned long long val);
-operator<<(float val);
-operator<<(double val);
-operator<<(long double val);
-operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
@@ -1393,49 +1489,90 @@ It provides formatting specifications such as field width, and a locale
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^34]
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
-*Returns:* `*this`.[^35]
 ``` cpp
-basic_ostream<charT, traits>& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
-function [[ostream.unformatted]]. After the sentry object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
@@ -1452,11 +1589,11 @@ the error state, and if `failbit` is set in `exceptions()` the caught
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -1529,29 +1666,98 @@ Determines padding for `seq` as described
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^36] in `*this`’s error state. If
-`(exceptions() & badbit) != 0` then the exception is rethrown. In any
-case, the unformatted output function ends by destroying the sentry
-object, then, if no exception was thrown, returning the value specified
-for the unformatted output function.
 ``` cpp
-basic_ostream<charT, traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, inserts the character `c`,
-if possible.[^37]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
@@ -1559,14 +1765,15 @@ Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, obtains characters to insert
-from successive locations of an array whose first element is designated
-by `s`.[^38] Characters are inserted until either of the following
-occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
@@ -1576,15 +1783,15 @@ occurs:
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). If `rdbuf()` is not a null pointer, constructs a sentry object.
-If this object returns `true` when converted to a value of type `bool`
-the function calls `rdbuf()->pubsync()`. If that function returns -1
-calls `setstate(badbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]). Otherwise, if the sentry object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
@@ -1654,11 +1861,14 @@ template<class charT, class traits>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
-of exposition, calls `buf->emit()`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
@@ -1688,11 +1898,11 @@ unspecified resetiosflags(ios_base::fmtflags mask);
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
-`f(in, mask)`, where the function `f` is defined as:[^39]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
@@ -1887,25 +2097,25 @@ void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
 The expression `out << put_money(mon, intl)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
-template<class charT> unspecified get_time(struct tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
-type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
-is a valid range.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
-void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
   using Iter    = istreambuf_iterator<charT, traits>;
   using TimeGet = time_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
@@ -1920,25 +2130,25 @@ void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
 The expression `in >> get_time(tmb, fmt)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
-template<class charT> unspecified put_time(const struct tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
-type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
-is a valid range.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
-void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
   using Iter    = ostreambuf_iterator<charT, traits>;
   using TimePut = time_put<charT, Iter>;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
@@ -2027,5 +2237,126 @@ template<class charT, class traits, class Allocator>
 - The expression `in >> quoted(s, delim, escape)` has type
   `basic_istream<charT, traits>&` and value `in`.
 - The expression `out << quoted(s, delim, escape)` has type
   `basic_ostream<charT, traits>&` and value `out`.

   using wiostream = basic_iostream<wchar_t>;
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
+  template<class Istream, class T>
+ Istream&& operator>>(Istream&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
+  template<class Ostream, class T>
+ Ostream&& operator<<(Ostream&& os, const T& x);
+  // [ostream.formatted.print], print functions
+  template<class... Args>
+    void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+  void vprint_unicode(ostream& os, string_view fmt, format_args args);
+  void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
+  unspecified resetiosflags(ios_base::fmtflags mask);
+ unspecified setiosflags  (ios_base::fmtflags mask);
+ unspecified setbase(int base);
+ template<class charT> unspecified setfill(charT c);
+ unspecified setprecision(int n);
+ unspecified setw(int n);
+ template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
+  template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
+  template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
+  template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
   template<class charT>
+ unspecified quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
+ unspecified quoted(const basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
+ unspecified quoted(basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits>
+ unspecified quoted(basic_string_view<charT, traits> s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 }
 ```
+### Header `<print>` synopsis <a id="print.syn">[[print.syn]]</a>
+``` cpp
+namespace std {
+  // [print.fun], print functions
+  template<class... Args>
+    void print(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  void vprint_unicode(string_view fmt, format_args args);
+  void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+  void vprint_nonunicode(string_view fmt, format_args args);
+  void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+}
+```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
+#### General <a id="input.streams.general">[[input.streams.general]]</a>
+The header `<istream>` defines two class templates and a function
+template that control input from a stream buffer, along with a function
+template that extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
+##### General <a id="istream.general">[[istream.general]]</a>
+When a function is specified with a type placeholder of
+`extended-floating-point-type`, the implementation provides overloads
+for all cv-unqualified extended floating-point types
+[[basic.fundamental]] in lieu of `extended-floating-{point-type}`.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
+    basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
+    basic_istream& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_istream& operator>>(ios_base& (*pf)(ios_base&));
+    basic_istream& operator>>(bool& n);
+    basic_istream& operator>>(short& n);
+    basic_istream& operator>>(unsigned short& n);
+    basic_istream& operator>>(int& n);
+    basic_istream& operator>>(unsigned int& n);
+    basic_istream& operator>>(long& n);
+    basic_istream& operator>>(unsigned long& n);
+    basic_istream& operator>>(long long& n);
+    basic_istream& operator>>(unsigned long long& n);
+    basic_istream& operator>>(float& f);
+    basic_istream& operator>>(double& f);
+    basic_istream& operator>>(long double& f);
+    basic_istream& operator>>(extended-floating-point-type& f);
+    basic_istream& operator>>(void*& p);
+    basic_istream& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
+    basic_istream& get(char_type& c);
+    basic_istream& get(char_type* s, streamsize n);
+    basic_istream& get(char_type* s, streamsize n, char_type delim);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
+    basic_istream& getline(char_type* s, streamsize n);
+    basic_istream& getline(char_type* s, streamsize n, char_type delim);
+    basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
+    basic_istream& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
+    basic_istream& putback(char_type c);
+    basic_istream& unget();
     int sync();
     pos_type tellg();
+    basic_istream& seekg(pos_type);
+    basic_istream& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
+    // [istream.assign], assignment and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
+    explicit sentry(basic_istream& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
   };
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_istream& is, bool noskipws = false);
 ```
 *Effects:* If `is.good()` is `false`, calls `is.setstate(failbit)`.
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
+`flush` may be eliminated entirely.[^18]
+If `noskipws` is zero and `is.flags() & ios_base::skipws` is nonzero,
+the function extracts and discards each character as long as the next
+available input character `c` is a whitespace character. If
+`is.rdbuf()->sbumpc()` or `is.rdbuf()->sgetc()` returns `traits::eof()`,
+the function calls `setstate(failbit | eofbit)` (which may throw
+`ios_base::failure`).
 *Remarks:* The constructor
 ``` cpp
+explicit sentry(basic_istream& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
+of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates an object of
+class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
+`bool`, the function endeavors to obtain the requested input. Otherwise,
+if the `sentry` constructor exits by throwing an exception or if the
+`sentry` object produces `false` when converted to a value of type
+`bool`, the function returns without attempting to obtain any input. If
+`rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`, then
+`ios_base::eofbit` is set in the local error state and the input
+function stops trying to obtain the requested input. If an exception is
+thrown during input then `ios_base::badbit` is set in the local error
+state, `*this`’s error state is set to the local error state, and the
+exception is rethrown if `(exceptions() & badbit) != 0`. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any case, the formatted input function destroys the
+`sentry` object. If no exception has been thrown, it returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
+basic_istream& operator>>(unsigned short& val);
+basic_istream& operator>>(unsigned int& val);
+basic_istream& operator>>(long& val);
+basic_istream& operator>>(unsigned long& val);
+basic_istream& operator>>(long long& val);
+basic_istream& operator>>(unsigned long long& val);
+basic_istream& operator>>(float& val);
+basic_istream& operator>>(double& val);
+basic_istream& operator>>(long double& val);
+basic_istream& operator>>(bool& val);
+basic_istream& operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
+described in  [[istream.formatted.reqmts]]). After a `sentry` object is
 constructed, the conversion occurs as if performed by the following code
+fragment, where `state` represents the input function’s local error
+state:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+use_facet<numget>(loc).get(*this, 0, *this, state, val);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
+basic_istream& operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<short>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
 ```
 ``` cpp
+basic_istream& operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<int>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
 ```
+``` cpp
+basic_istream& operator>>(extended-floating-point-type& val);
+```
+If the floating-point conversion rank of
+*`extended-floating-point-type`* is not less than or equal to that of
+`long double`, then an invocation of the operator function is
+conditionally supported with *implementation-defined* semantics.
+Otherwise, let `FP` be a standard floating-point type:
+- if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `float`, then `FP` is `float`,
+- otherwise, if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `double`, then `FP` is `double`,
+- otherwise, `FP` is `long double`.
+The conversion occurs as if performed by the following code fragment
+(using the same notation as for the preceding code fragment):
+``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+FP fval;
+use_facet<numget>(loc).get(*this, 0, *this, state, fval);
+if (fval < -numeric_limits<extended-floating-point-type>::max()) {
+  state |= ios_base::failbit;
+  val = -numeric_limits<extended-floating-point-type>::max();
+} else if (numeric_limits<extended-floating-point-type>::max() < fval) {
+  state |= ios_base::failbit;
+  val = numeric_limits<extended-floating-point-type>::max();
+} else {
+  val = static_cast<extended-floating-point-type>(fval);
+}
+```
+[*Note 2*: When the extended floating-point type has a floating-point
+conversion rank that is not equal to the rank of any standard
+floating-point type, then double rounding during the conversion can
+result in inaccurate results. `from_chars` can be used in situations
+where maximum accuracy is important. — *end note*]
 ##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
+basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]]).
+*Returns:* `pf(*this)`. [^20]
 ``` cpp
+basic_istream& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& operator>>(ios_base& (*pf)(ios_base&));
 ```
+*Effects:* Calls `pf(*this)`.[^21]
+This extractor does not behave as a formatted input function (as
+described in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
 template<class charT, class traits, size_t N>
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
+If the function extracted no characters, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
+in  [[istream.formatted.reqmts]]) of `in`. A character is extracted from
+`in`, if one is available, and stored in `c`. Otherwise,
+`ios_base::failbit` is set in the input function’s local error state
+before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
+basic_istream& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
+[[iostate.flags]]. After a `sentry` object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
+object of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates an object of
+class `sentry` with the default argument `noskipws` (second) argument
+`true`. If the `sentry` object returns `true`, when converted to a value
+of type `bool`, the function endeavors to obtain the requested input.
+Otherwise, if the `sentry` constructor exits by throwing an exception or
+if the `sentry` object produces `false`, when converted to a value of
+type `bool`, the function returns without attempting to obtain any
+input. In either case the number of extracted characters is set to 0;
+unformatted input functions taking a character array of nonzero size as
+an argument shall also store a null character (using `charT()`) in the
+first location of the array. If `rdbuf()->sbumpc()` or
+`rdbuf()->sgetc()` returns `traits::eof()`, then `ios_base::eofbit` is
+set in the local error state and the input function stops trying to
+obtain the requested input. If an exception is thrown during input then
+`ios_base::badbit` is set in the local error state, `*this`’s error
+state is set to the local error state, and the exception is rethrown if
+`(exceptions() & badbit) != 0`. If no exception has been thrown it
+stores the number of characters extracted in a member object. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any event the `sentry` object is destroyed before leaving
+the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
+input member function called for the object. If the number cannot be
+represented, returns `numeric_limits<streamsize>::max()`.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character `c`,
+if one is available. Otherwise, `ios_base::failbit` is set in the input
+function’s local error state before `setstate` is called.
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
+basic_istream& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character, if
+one is available, and assigns it to `c`.[^22]
+Otherwise, `ios_base::failbit` is set in the input function’s local
+error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 stores them into successive locations of an array whose first element is
+designated by `s`.[^23]
+Characters are extracted and stored until any of the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
+- end-of-file occurs on the input sequence;
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
+If the function stores no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called. In any
+case, if `n` is greater than zero it then stores a null character into
+the next successive location of the array.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 stores them into successive locations of an array whose first element is
+designated by `s`.[^24]
+Characters are extracted and stored until one of the following occurs:
+1.  end-of-file occurs on the input sequence;
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
+    stored);[^25]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
+These conditions are tested in the order shown.[^26]
+If the function extracts no characters, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.[^27]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
 ```
 — *end example*]
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
+basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
   calls `setstate(eofbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]);
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
+[*Note 1*: The last condition will never occur if
+`traits::eq_int_type(delim, traits::eof())`. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
+basic_istream& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
+array whose first element is designated by `s`.[^28]
+Characters are extracted and stored until either of the following
+occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
   `ios_base::failure` [[iostate.flags]]).
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
+basic_istream& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
+``` cpp
+basic_istream& unget();
+```
+*Effects:* Behaves as an unformatted input function (as described
+above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
+which may throw an exception, and return. If `rdbuf()` is not null,
+calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
+returns `traits::eof()`, calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).
+[*Note 3*: This function extracts no characters, so the value returned
+by the next call to `gcount()` is 0. — *end note*]
+*Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
+`gcount()`. After constructing a `sentry` object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
+*Returns:* After constructing a `sentry` object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
+basic_istream& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
+returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
+subsequent calls to `is.gcount()`. After constructing a `sentry` object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
+when treated as an unevaluated operand [[term.unevaluated.operand]] and
+`Istream` is publicly and unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
+##### General <a id="iostreamclass.general">[[iostreamclass.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
+    // [iostream.assign], assignment and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
+`basic_istream` base class with `std::move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
 ### Output streams <a id="output.streams">[[output.streams]]</a>
+#### General <a id="output.streams.general">[[output.streams.general]]</a>
+The header `<ostream>` defines a class template and several function
+templates that control output to a stream buffer, along with a function
+template that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
+##### General <a id="ostream.general">[[ostream.general]]</a>
+When a function has a parameter type `extended-floating-point-type`, the
+implementation provides overloads for all cv-unqualified extended
+floating-point types [[basic.fundamental]].
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
+    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
+    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
+    basic_ostream& operator<<(bool n);
+    basic_ostream& operator<<(short n);
+    basic_ostream& operator<<(unsigned short n);
+    basic_ostream& operator<<(int n);
+    basic_ostream& operator<<(unsigned int n);
+    basic_ostream& operator<<(long n);
+    basic_ostream& operator<<(unsigned long n);
+    basic_ostream& operator<<(long long n);
+    basic_ostream& operator<<(unsigned long long n);
+    basic_ostream& operator<<(float f);
+    basic_ostream& operator<<(double f);
+    basic_ostream& operator<<(long double f);
+    basic_ostream& operator<<(extended-floating-point-type f);
+    basic_ostream& operator<<(const void* p);
+    basic_ostream& operator<<(const volatile void* p);
+    basic_ostream& operator<<(nullptr_t);
+    basic_ostream& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
+    basic_ostream& put(char_type c);
+    basic_ostream& write(const char_type* s, streamsize n);
+    basic_ostream& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
+    basic_ostream& seekp(pos_type);
+    basic_ostream& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
+    // [ostream.assign], assignment and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
+    explicit sentry(basic_ostream& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_ostream& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
+If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^29]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).[^30]
 ``` cpp
 ~sentry();
 ```
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
+basic_ostream& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
+function does `setstate(ios_base::failbit)`, which can throw an
 exception. If an exception is thrown during output, then
+`ios_base::badbit` is set[^31]
+in `*this`’s error state. If `(exceptions()&badbit) != 0` then the
+exception is rethrown. Whether or not an exception is thrown, the
+`sentry` object is destroyed before leaving the formatted output
+function. If no exception is thrown, the result of the formatted output
+function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
+basic_ostream& operator<<(bool val);
+basic_ostream& operator<<(short val);
+basic_ostream& operator<<(unsigned short val);
+basic_ostream& operator<<(int val);
+basic_ostream& operator<<(unsigned int val);
+basic_ostream& operator<<(long val);
+basic_ostream& operator<<(unsigned long val);
+basic_ostream& operator<<(long long val);
+basic_ostream& operator<<(unsigned long long val);
+basic_ostream& operator<<(float val);
+basic_ostream& operator<<(double val);
+basic_ostream& operator<<(long double val);
+basic_ostream& operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
+``` cpp
+basic_ostream& operator<<(const volatile void* p);
+```
+*Effects:* Equivalent to:
+`return operator<<(const_cast<const void*>(p));`
+``` cpp
+basic_ostream& operator<<(extended-floating-point-type val);
+```
+*Effects:* If the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<double>(val)).failed();
+```
+Otherwise, if the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`long double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<long double>(val)).failed();
+```
+Otherwise, an invocation of the operator function is conditionally
+supported with *implementation-defined* semantics.
+If `failed` is `true` then does `setstate(badbit)`, which may throw an
+exception, and returns.
+*Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
+basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^32]
 ``` cpp
+basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
+*Returns:* `*this`.[^33]
 ``` cpp
+basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
+function [[ostream.unformatted]]. After the `sentry` object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
+##### Print <a id="ostream.formatted.print">[[ostream.formatted.print]]</a>
+``` cpp
+template<class... Args>
+  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
+equivalent to:
+``` cpp
+vprint_unicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+Otherwise, equivalent to:
+``` cpp
+vprint_nonunicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+``` cpp
+template<class... Args>
+  void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(os, "{}\n", format(fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void vprint_unicode(ostream& os, string_view fmt, format_args args);
+void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
+```
+*Effects:* Behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `os`, except that:
+- failure to generate output is reported as specified below, and
+- any exception thrown by the call to `vformat` is propagated without
+  regard to the value of `os.exceptions()` and without turning on
+  `ios_base::badbit` in the error state of `os`.
+After constructing a `sentry` object, the function initializes an
+automatic variable via
+``` cpp
+string out = vformat(os.getloc(), fmt, args);
+```
+If the function is `vprint_unicode` and `os` is a stream that refers to
+a terminal capable of displaying Unicode which is determined in an
+implementation-defined manner, writes `out` to the terminal using the
+native Unicode API; if `out` contains invalid code units, the behavior
+is undefined and implementations are encouraged to diagnose it. If the
+native Unicode API is used, the function flushes `os` before writing
+`out`. Otherwise (if `os` is not such a stream or the function is
+`vprint_nonunicode`), inserts the character sequence \[`out.begin()`,
+`out.end()`) into `os`. If writing to the terminal or inserting into
+`os` fails, calls `os.setstate(ios_base::badbit)` (which may throw
+`ios_base::failure`).
+*Recommended practice:* For `vprint_unicode`, if invoking the native
+Unicode API requires transcoding, implementations should substitute
+invalid code units with U+fffd (replacement character) per the Unicode
+Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
+`ios_base::badbit` is set[^34]
+in `*this`’s error state. If `(exceptions() & badbit) != 0` then the
+exception is rethrown. In any case, the unformatted output function ends
+by destroying the `sentry` object, then, if no exception was thrown,
+returning the value specified for the unformatted output function.
 ``` cpp
+basic_ostream& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, inserts the character `c`,
+if possible.[^35]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, obtains characters to
+insert from successive locations of an array whose first element is
+designated by `s`.[^36]
+Characters are inserted until either of the following occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). If `rdbuf()` is not a null pointer, constructs a `sentry`
+object. If that object returns `true` when converted to a value of type
+`bool` the function calls `rdbuf()->pubsync()`. If that function returns
+-1 calls `setstate(badbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, behaves as an unformatted output
+function [[ostream.unformatted]] of `os`. After constructing a `sentry`
+object, calls `buf->emit()`. If that call returns `false`, calls
+`os.setstate(ios_base::badbit)`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
+`f(in, mask)`, where the function `f` is defined as:[^37]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
 The expression `out << put_money(mon, intl)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
+template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`) is a
+valid range.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
+void f(basic_ios<charT, traits>& str, tm* tmb, const charT* fmt) {
   using Iter    = istreambuf_iterator<charT, traits>;
   using TimeGet = time_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
 The expression `in >> get_time(tmb, fmt)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
+template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`) is a
+valid range.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
+void f(basic_ios<charT, traits>& str, const tm* tmb, const charT* fmt) {
   using Iter    = ostreambuf_iterator<charT, traits>;
   using TimePut = time_put<charT, Iter>;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
 - The expression `in >> quoted(s, delim, escape)` has type
   `basic_istream<charT, traits>&` and value `in`.
 - The expression `out << quoted(s, delim, escape)` has type
   `basic_ostream<charT, traits>&` and value `out`.
+### Print functions <a id="print.fun">[[print.fun]]</a>
+``` cpp
+template<class... Args>
+  void print(format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stdout, fmt, std::forward<Args>(args)...);
+```
+``` cpp
+template<class... Args>
+  void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
+equivalent to:
+``` cpp
+vprint_unicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+Otherwise, equivalent to:
+``` cpp
+vprint_nonunicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+``` cpp
+template<class... Args>
+  void println(format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+println(stdout, fmt, std::forward<Args>(args)...);
+```
+``` cpp
+template<class... Args>
+  void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stream, "{}\n", format(fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void vprint_unicode(string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+vprint_unicode(stdout, fmt, args);
+```
+``` cpp
+void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+```
+*Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* The function initializes an automatic variable via
+``` cpp
+string out = vformat(fmt, args);
+```
+If `stream` refers to a terminal capable of displaying Unicode, writes
+`out` to the terminal using the native Unicode API; if `out` contains
+invalid code units, the behavior is undefined and implementations are
+encouraged to diagnose it. Otherwise writes `out` to `stream` unchanged.
+If the native Unicode API is used, the function flushes `stream` before
+writing `out`.
+[*Note 1*: On POSIX and Windows, `stream` referring to a terminal means
+that, respectively, `isatty(fileno(stream))` and
+`GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)` return
+nonzero. — *end note*]
+[*Note 2*: On Windows, the native Unicode API is
+`WriteConsoleW`. — *end note*]
+*Throws:* Any exception thrown by the call to `vformat`
+[[format.err.report]]. `system_error` if writing to the terminal or
+`stream` fails. May throw `bad_alloc`.
+*Recommended practice:* If invoking the native Unicode API requires
+transcoding, implementations should substitute invalid code units with
+U+fffd (replacement character) per the Unicode Standard, Chapter 3.9
+‘U+fffd‘ Substitution in Conversion.
+``` cpp
+void vprint_nonunicode(string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+vprint_nonunicode(stdout, fmt, args);
+```
+``` cpp
+void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+```
+*Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* Writes the result of `vformat(fmt, args)` to `stream`.
+*Throws:* Any exception thrown by the call to `vformat`
+[[format.err.report]]. `system_error` if writing to `stream` fails. May
+throw `bad_alloc`.

Diff to HTML by rtfpessoa