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

Files changed (1) hide show

tmp/tmp1uls7k6g/{from.md → to.md} +99 -106

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

@@ -9,22 +9,22 @@ extracts from stream rvalues.
 ``` cpp
 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>&));
@@ -74,15 +74,15 @@ namespace std {
     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
@@ -91,16 +91,16 @@ namespace std {
   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
@@ -113,72 +113,67 @@ 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 error
-state. If `badbit` is on 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.
-##### `basic_istream` constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` 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);
 ```
-*Effects:* Move constructs from the rvalue `rhs`. This is accomplished
-by default constructing the base class, copying the `gcount()` from
-`rhs`, calling `basic_ios<charT, traits>::move(rhs)` to initialize the
-base class, and setting the `gcount()` for `rhs` to 0.
 ``` cpp
 virtual ~basic_istream();
 ```
-*Effects:* Destroys an object of class `basic_istream`.
 *Remarks:* Does not perform any operations of `rdbuf()`.
-##### Class `basic_istream` assign and swap <a id="istream.assign">[[istream.assign]]</a>
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`. Exchanges the
 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 {
-    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_; }
@@ -229,11 +224,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]]))[^19]
 ``` cpp
 ~sentry();
 ```
@@ -241,23 +236,23 @@ constructor may call `setstate(failbit)` (which may throw
 ``` cpp
 explicit operator bool() const;
 ```
-*Effects:* Returns `ok_`.
 #### 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::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>
@@ -274,11 +269,11 @@ 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:
@@ -378,26 +373,23 @@ 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
-successive locations of an array whose first element is designated by
-`s`. If `width()` is greater than zero, `n` is `width()`. Otherwise `n`
-is the number of elements of the largest array of `char_type` that can
-store a terminating `charT()`. `n` is the maximum number of characters
-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;
@@ -407,11 +399,11 @@ 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>
@@ -431,28 +423,28 @@ stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 ``` 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 on in
-`exceptions()` ([[iostate.flags]]), then the caught exception is
-rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
@@ -465,14 +457,14 @@ 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
@@ -490,23 +482,23 @@ 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);
@@ -523,13 +515,13 @@ the following occurs:
   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);
@@ -555,11 +547,11 @@ extracted and inserted until any of the following occurs:
   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);
@@ -588,11 +580,11 @@ the following occurs:
     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.
@@ -640,15 +632,15 @@ basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::
 *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
   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())`.
@@ -678,11 +670,11 @@ 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]])).
 *Returns:* `*this`.
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
@@ -692,11 +684,11 @@ streamsize readsome(char_type* s, streamsize n);
 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.
@@ -707,13 +699,13 @@ 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`.
@@ -724,13 +716,13 @@ 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`.
@@ -743,11 +735,11 @@ int sync();
 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();
 ```
@@ -791,45 +783,49 @@ function calls `setstate(failbit)` (which may throw
 *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>>
@@ -849,62 +845,59 @@ namespace std {
     // [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);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
 `basic_istream` base class with `move(rhs)`.
-##### `basic_iostream` destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
 ```
-*Effects:* Destroys an object of class `basic_iostream`.
 *Remarks:* Does not perform any operations on `rdbuf()`.
-##### `basic_iostream` assign and swap <a id="iostream.assign">[[iostream.assign]]</a>
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```

 ``` cpp
 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>& 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);
   };
   // [istream.extractors], character extraction templates
   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, size_t N>
+    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT(&)[N]);
+  template<class traits, size_t N>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char(&)[N]);
+  template<class traits, size_t N>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char(&)[N]);
 }
 ```
 The class template `basic_istream` defines a number of member function
 signatures that assist in reading and interpreting input from sequences
 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);
 ```
+*Effects:* Initializes the base class subobject with
+`basic_ios::init(sb)` [[basic.ios.cons]].
+*Ensures:* `gcount() == 0`.
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
+*Effects:* Default constructs the base class, copies the `gcount()` from
+`rhs`, calls `basic_ios<charT, traits>::move(rhs)` to initialize the
+base class, and sets the `gcount()` for `rhs` to 0.
 ``` cpp
 virtual ~basic_istream();
 ```
 *Remarks:* Does not perform any operations of `rdbuf()`.
+##### Assignment and swap <a id="istream.assign">[[istream.assign]]</a>
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`. Exchanges the
 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_; }
 ```
 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();
 ```
 ``` cpp
 explicit operator bool() const;
 ```
+*Returns:* `ok_`.
 #### 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>
 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:
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+template<class charT, class traits, size_t N>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT (&s)[N]);
+template<class traits, size_t N>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char (&s)[N]);
+template<class traits, size_t N>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char (&s)[N]);
 ```
 *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 `s`.
+If `width()` is greater than zero, `n` is `min(size_t(width()), N)`.
+Otherwise `n` is `N`. `n` is the maximum number of characters 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;
 `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>
 ``` 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>
 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
 ```
 *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);
   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);
   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);
     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.
 *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
   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())`.
 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]]).
 *Returns:* `*this`.
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 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.
 *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`.
 *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`.
 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();
 ```
 *Returns:* `*this`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
+Each instantiation of the function template specified in this subclause
+is a designated addressable function [[namespace.std]].
 ``` 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 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>>
     // [iostream.dest], destructor
     virtual ~basic_iostream();
   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);
   };
 }
 ```
 The class template `basic_iostream` inherits a number of functions that
 allow reading input and writing output to sequences controlled by a
 stream buffer.
+##### Constructors <a id="iostream.cons">[[iostream.cons]]</a>
 ``` cpp
 explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Initializes the base class subobjects with
+`basic_istream<charT, traits>(sb)` [[istream]] and
+`basic_ostream<charT, traits>(sb)` [[ostream]].
+*Ensures:* `rdbuf() == sb` and `gcount() == 0`.
 ``` 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();
 ```
 *Remarks:* Does not perform any operations on `rdbuf()`.
+##### Assignment and swap <a id="iostream.assign">[[iostream.assign]]</a>
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```

Diff to HTML by rtfpessoa