[input.streams] - C++14 → C++17

Files changed (1) hide show

tmp/tmp0c03tj9i/{from.md → to.md} +213 -222

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

@@ -10,30 +10,30 @@ extracts from stream rvalues.
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios ([ios])):
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [istream.cons] Constructor/destructor:
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
-    // [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);
@@ -45,30 +45,25 @@ namespace std {
     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);
@@ -78,45 +73,40 @@ namespace std {
     pos_type tellg();
     basic_istream<charT, traits>& seekg(pos_type);
     basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     basic_istream(const basic_istream& rhs) = delete;
     basic_istream(basic_istream&& rhs);
-    // [istream.assign] Assign/swap:
     basic_istream& operator=(const basic_istream& rhs) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
-  // [istream::extractors] character extraction templates:
   template<class charT, class traits>
-    basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
-                                            charT&);
   template<class traits>
-    basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                           unsigned char&);
   template<class traits>
-    basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                           signed char&);
   template<class charT, class traits>
-    basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
-                                            charT*);
   template<class traits>
-    basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                           unsigned char*);
   template<class traits>
-    basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                           signed char*);
 }
 ```
-The class `basic_istream` defines a number of member function signatures
-that assist in reading and interpreting input from sequences controlled
-by a stream buffer.
 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()`
@@ -138,15 +128,15 @@ failure indication.
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_istream`, assigning
-initial values to the base class by calling
 `basic_ios::init(sb)` ([[basic.ios.cons]]).
-`gcount() == 0`
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
@@ -167,11 +157,11 @@ virtual ~basic_istream();
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* `swap(rhs);`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
@@ -184,11 +174,11 @@ values returned by `gcount()` and `rhs.gcount()`.
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
- typedef traits traits_type;
     bool ok_; // exposition only
   public:
     explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
@@ -211,19 +201,23 @@ Otherwise, prepares for formatted or unformatted input. First, if
 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.[^17] 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
-`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.
 To decide if the character `c` is a whitespace character, the
 constructor performs as if it executes the following code fragment:
@@ -235,11 +229,11 @@ if (ctype.is(ctype.space,c)!=0)
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]))[^18]
 ``` cpp
 ~sentry();
 ```
@@ -257,11 +251,11 @@ explicit operator bool() const;
 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::badbit` is turned on[^19] 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`.
@@ -287,32 +281,36 @@ 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
-typedef num_get< charT,istreambuf_iterator<charT,traits> > numget;
 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. The first argument provides an object of the
 `istreambuf_iterator` class which is an iterator pointed to an input
-stream. It bypasses istreams and uses streambufs directly. 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
-typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
 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;
@@ -331,11 +329,11 @@ 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
-typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
 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;
@@ -346,54 +344,50 @@ if (lval < numeric_limits<int>::min()) {
 }  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)`.[^20]
 ``` 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)`.[^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>
-  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& in,
-                                          charT* s);
 template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
-                                         unsigned char* s);
 template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
-                                         signed char* s);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
 constructed, `operator>>` extracts characters and stores them into
@@ -405,12 +399,12 @@ stored.
 Characters are extracted and stored until any of the following occurs:
 - `n-1` characters are stored;
 - end of file occurs on the input sequence;
-- `ct.is(ct.space,c)` is `true` for the next available input character
-  `c`, where `ct` is `use_facet<ctype<charT> >(in.getloc())`.
 `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)`.
@@ -419,38 +413,33 @@ which may throw `ios_base::failure` ([[iostate.flags]]).
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
-  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& in,
-                                          charT& c);
 template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
-                                         unsigned char& c);
 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 (as described
-in  [[istream.unformatted]], paragraph 1). 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);
@@ -470,18 +459,18 @@ rethrown.
 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 non-zero 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::badbit` is turned on[^22] 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.
@@ -489,49 +478,47 @@ 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 in  [[istream.unformatted]], paragraph 1).
 *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
-in  [[istream.unformatted]], paragraph 1). 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
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts a character, if one is available, and assigns it to
-`c`.[^23] 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
-in  [[istream.unformatted]], paragraph 1). 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 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
@@ -546,24 +533,22 @@ next successive location of the array.
 ``` 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
-in  [[istream.unformatted]], paragraph 1). 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
   be inserted is not extracted);
 - `traits::eq(c, delim)` for the next available input character `c` (in
@@ -578,44 +563,45 @@ which may throw `ios_base::failure` ([[iostate.flags]]).
 ``` 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
-in  [[istream.unformatted]], paragraph 1). 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 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);[^26]
 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.[^27]
 If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])).[^28]
 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.
 *Returns:* `*this`.
 ``` cpp
 #include <iostream>
 int main() {
   using namespace std;
@@ -637,27 +623,28 @@ int main() {
     cout << " (" << count << " chars): " << buffer << endl;
   }
 }
 ```
 ``` 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
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts characters and discards them. Characters are extracted
-until any of the following occurs:
-- `n != numeric_limits<streamsize>::max()` ([[limits]]) and `n`
   characters have been extracted so far
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`, which may throw
   `ios_base::failure` ([[iostate.flags]]));
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
@@ -671,27 +658,26 @@ until any of the following occurs:
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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
-in  [[istream.unformatted]], paragraph 1). 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`.[^29] 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]])).
@@ -701,17 +687,16 @@ following occurs:
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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 no characters
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
@@ -719,86 +704,87 @@ characters;
 ``` cpp
 basic_istream<charT, traits>& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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()`. If `rdbuf()` is null,
-or if `sputbackc()` returns `traits::eof()`, calls `setstate(badbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])). This
-function extracts no characters, so the value returned by the next call
-to `gcount()` is 0.
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& unget();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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]])). This
-function extracts no characters, so the value returned by the next call
-to `gcount()` is 0.
 *Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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.
 ``` cpp
 pos_type tellg();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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
-in  [[istream.unformatted]], paragraph 1), 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
-in  [[istream.unformatted]], paragraph 1), 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 `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`).
@@ -806,77 +792,94 @@ function calls `setstate(failbit)` (which may throw
 *Returns:* `*this`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
 ``` cpp
-namespace std {
 template <class charT, class traits>
   basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
-}
 ```
-*Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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
 `failbit`.
 *Returns:* `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>,
       public basic_ostream<charT, traits> {
   public:
- // types:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
-    typedef traits                    traits_type;
-    // constructor/destructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_iostream();
   protected:
     basic_iostream(const basic_iostream& rhs) = delete;
     basic_iostream(basic_iostream&& rhs);
-    // assign/swap
     basic_iostream& operator=(const basic_iostream& rhs) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ```
-The class `basic_iostream` inherits a number of functions that allow
-reading input and writing output to sequences controlled by a stream
-buffer.
 ##### `basic_iostream` constructors <a id="iostream.cons">[[iostream.cons]]</a>
 ``` cpp
 explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_iostream`, assigning
-initial values to the base classes by calling
 `basic_istream<charT, traits>(sb)` ([[istream]]) and
-`basic_ostream<charT,traits>(sb)` ([[ostream]])
-`rdbuf()==sb` and `gcount()==0`.
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
@@ -897,25 +900,13 @@ virtual ~basic_iostream();
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
-#### Rvalue stream extraction <a id="istream.rvalue">[[istream.rvalue]]</a>
-``` cpp
-template <class charT, class traits, class T>
-  basic_istream<charT, traits>&
-  operator>>(basic_istream<charT, traits>&& is, T& x);
-```
-*Effects:* `is >>x`
-*Returns:* `is`

 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios ([ios])):
+ using char_type   = charT;
+ using int_type    = typename traits::int_type;
+ using pos_type    = typename traits::pos_type;
+ using off_type    = typename traits::off_type;
+ using traits_type = traits;
+    // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
+    // [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>>(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);
     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& rhs) = delete;
     basic_istream(basic_istream&& rhs);
+    // [istream.assign], assign and swap
     basic_istream& operator=(const basic_istream& rhs) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
+  // [istream.extractors], character extraction templates
   template<class charT, class traits>
+    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT&);
   template<class traits>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char&);
   template<class traits>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char&);
   template<class charT, class traits>
+    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT*);
   template<class traits>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char*);
   template<class traits>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char*);
 }
 ```
+The class template `basic_istream` defines a number of member function
+signatures that assist in reading and interpreting input from sequences
+controlled by a stream buffer.
 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()`
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Constructs an object of class `basic_istream`, initializing
+the base class subobject with
 `basic_ios::init(sb)` ([[basic.ios.cons]]).
+*Postconditions:* `gcount() == 0`.
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
+ using traits_type = traits;
     bool ok_; // exposition only
   public:
     explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
 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.
 To decide if the character `c` is a whitespace character, the
 constructor performs as if it executes the following code fragment:
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` ([[iostate.flags]]))[^19]
 ``` cpp
 ~sentry();
 ```
 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::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`.
 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.
+[*Note 1*: The first argument provides an object of the
 `istreambuf_iterator` class which is an iterator pointed to an input
+stream. It bypasses istreams and uses streambufs
+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;
 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;
 }  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>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT* s);
 template<class traits>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char* s);
 template<class traits>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char* s);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
 constructed, `operator>>` extracts characters and stores them into
 Characters are extracted and stored until any of the following occurs:
 - `n-1` characters are stored;
 - end of file occurs on the input sequence;
+- letting `ct` be `use_facet<ctype<charT>>(in.getloc())`,
+  `ct.is(ct.space, c)` is `true`.
 `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)`.
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT& c);
 template<class traits>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char& c);
 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);
 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::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
 ``` 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
   be inserted is not extracted);
 - `traits::eq(c, delim)` for the next available input character `c` (in
 ``` 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.
 *Returns:* `*this`.
+[*Example 1*:
 ``` cpp
 #include <iostream>
 int main() {
   using namespace std;
     cout << " (" << count << " chars): " << buffer << endl;
   }
 }
 ```
+— *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
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`, which may throw
   `ios_base::failure` ([[iostate.flags]]));
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
 ``` 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]])).
 ``` 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 no characters
 - 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()`. 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.
 ``` cpp
 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`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
 ``` cpp
 template <class charT, class traits>
   basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
 ```
+*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
 `failbit`.
 *Returns:* `is`.
+#### Rvalue stream extraction <a id="istream.rvalue">[[istream.rvalue]]</a>
+``` cpp
+template <class charT, class traits, class T>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
+```
+*Effects:* Equivalent to:
+``` cpp
+is >> std::forward<T>(x);
+return is;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless the expression `is >> std::forward<T>(x)` is well-formed.
 #### 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>,
       public basic_ostream<charT, traits> {
   public:
+ using char_type   = charT;
+ using int_type    = typename traits::int_type;
+ using pos_type    = typename traits::pos_type;
+ using off_type    = typename traits::off_type;
+ using traits_type = traits;
+    // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
+    // [iostream.dest], destructor
     virtual ~basic_iostream();
   protected:
+    // [iostream.cons], constructor
     basic_iostream(const basic_iostream& rhs) = delete;
     basic_iostream(basic_iostream&& rhs);
+    // [iostream.assign], assign and swap
     basic_iostream& operator=(const basic_iostream& rhs) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ```
+The class template `basic_iostream` inherits a number of functions that
+allow reading input and writing output to sequences controlled by a
+stream buffer.
 ##### `basic_iostream` constructors <a id="iostream.cons">[[iostream.cons]]</a>
 ``` cpp
 explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Constructs an object of class `basic_iostream`, initializing
+the base class subobjects with
 `basic_istream<charT, traits>(sb)` ([[istream]]) and
+`basic_ostream<charT, traits>(sb)` ([[ostream]]).
+*Postconditions:* `rdbuf() == sb` and `gcount() == 0`.
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* As if by `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.

Diff to HTML by rtfpessoa