namespace std {
template<class charT, class traits = char_traits<charT>>
class basic_istream : virtual public basic_ios<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;
explicit basic_istream(basic_streambuf<charT, traits>* sb);
virtual ~basic_istream();
class sentry;
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
basic_istream<charT, traits>&
operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
basic_istream<charT, traits>&
operator>>(ios_base& (*pf)(ios_base&));
basic_istream<charT, traits>& operator>>(bool& n);
basic_istream<charT, traits>& operator>>(short& n);
basic_istream<charT, traits>& operator>>(unsigned short& n);
basic_istream<charT, traits>& operator>>(int& n);
basic_istream<charT, traits>& operator>>(unsigned int& n);
basic_istream<charT, traits>& operator>>(long& n);
basic_istream<charT, traits>& operator>>(unsigned long& n);
basic_istream<charT, traits>& operator>>(long long& n);
basic_istream<charT, traits>& operator>>(unsigned long long& n);
basic_istream<charT, traits>& operator>>(float& f);
basic_istream<charT, traits>& operator>>(double& f);
basic_istream<charT, traits>& operator>>(long double& f);
basic_istream<charT, traits>& operator>>(void*& p);
basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);
streamsize gcount() const;
int_type get();
basic_istream<charT, traits>& get(char_type& c);
basic_istream<charT, traits>& get(char_type* s, streamsize n);
basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
basic_istream<charT, traits>& getline(char_type* s, streamsize n);
basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
int_type peek();
basic_istream<charT, traits>& read (char_type* s, streamsize n);
streamsize readsome(char_type* s, streamsize n);
basic_istream<charT, traits>& putback(char_type c);
basic_istream<charT, traits>& unget();
int sync();
pos_type tellg();
basic_istream<charT, traits>& seekg(pos_type);
basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
protected:
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& rhs);
basic_istream& operator=(const basic_istream&) = delete;
basic_istream& operator=(basic_istream&& rhs);
void swap(basic_istream& rhs);
};
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, 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
controlled by a stream buffer
. 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
.namespace std {
template<class charT, class traits = char_traits<charT>>
class basic_istream<charT, traits>::sentry {
bool ok_;
public:
explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
~sentry();
explicit operator bool() const { return ok_; }
sentry(const sentry&) = delete;
sentry& operator=(const sentry&) = delete;
};
}
The class
sentry
defines a class that is responsible for doing exception safe prefix and suffix
operations
.explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
Effects: If
is.good()
is
false,
calls
is.setstate(failbit). Otherwise,
prepares for formatted or
unformatted input
. First, if
is.tie()
is not a null pointer, the
function calls
is.tie()->flush()
to synchronize the output sequence with any associated external
C stream
. Except that this call can be suppressed if the put area of
is.tie()
is empty
. Further an implementation is allowed to defer the call to
flush
until a
call of
is.rdbuf()->underflow()
occurs
. If no such call occurs before the
sentry
object is destroyed, the call to
flush
may be eliminated entirely
.
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:
const ctype<charT>& ctype = use_facet<ctype<charT>>(is.getloc());
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]))
.explicit operator bool() const;