27 Input/output library [input.output]

27.7 Formatting and manipulators [iostream.format]

27.7.2 Input streams [input.streams]

27.7.2.2 Formatted input functions [istream.formatted]

27.7.2.2.1 Common requirements [istream.formatted.reqmts]

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 on314 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.

This is done without causing an ios::failure to be thrown.

27.7.2.2.2 Arithmetic extractors [istream.formatted.arithmetic]

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:

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. [ Note: 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.

operator>>(short& val);

The conversion occurs as if performed by the following code fragment (using the same notation as for the preceding code fragment):

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;
  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);

operator>>(int& val);

The conversion occurs as if performed by the following code fragment (using the same notation as for the preceding code fragment):

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;
  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);

27.7.2.2.3 basic_istream::operator>> [istream::extractors]

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).315

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.

basic_istream<charT,traits>& operator>> (ios_base& (*pf)(ios_base&));

Effects: Calls pf(*this).316 This extractor does not behave as a formatted input function (as described in [istream.formatted.reqmts]).

Returns: *this.

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;

  • 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).

If the function extracted no characters, it calls setstate(failbit), which may throw ios_base::failure ([iostate.flags]).

Returns: in.

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.

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);

  • 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.

See, for example, the function signature ws(basic_istream&) ([istream.manip]).

See, for example, the function signature dec(ios_base&) ([basefield.manip]).