文档库 最新最全的文档下载
当前位置:文档库 › istream

istream

// istream standard header
#pragma once
#ifndef _ISTREAM_
#define _ISTREAM_
#ifndef RC_INVOKED
#include

#ifdef _MSC_VER
#pragma pack(push,_CRT_PACKING)
#pragma warning(push,3)
#endif /* _MSC_VER */

_STD_BEGIN

// TEMPLATE CLASS basic_istream
templateclass _Traits>
class basic_istream
: virtual public basic_ios<_Elem, _Traits>
{ // control extractions from a stream buffer
public:
typedef basic_istream<_Elem, _Traits> _Myt;
typedef basic_ios<_Elem, _Traits> _Myios;
typedef basic_streambuf<_Elem, _Traits> _Mysb;
typedef istreambuf_iterator<_Elem, _Traits> _Iter;
typedef ctype<_Elem> _Ctype;
typedef num_get<_Elem, _Iter> _Nget;


explicit __CLR_OR_THIS_CALL basic_istream(_Mysb *_Strbuf, bool _Isstd = false)
: _Chcount(0)
{ // construct from stream buffer pointer
_Myios::init(_Strbuf, _Isstd);
}

__CLR_OR_THIS_CALL basic_istream(_Uninitialized)
{ // construct uninitialized
ios_base::_Addstd(this);
}

virtual __CLR_OR_THIS_CALL ~basic_istream()
{ // destroy the object
}

typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;

// TEMPLATE CLASS sentry
class _Sentry_base
{ // stores thread lock and reference to input stream
public:
__CLR_OR_THIS_CALL _Sentry_base(_Myt& _Istr)
: _Myistr(_Istr)
{ // lock the stream buffer, if there
if (_Myistr.rdbuf() != 0)
_Myistr.rdbuf()->_Lock();
}

__CLR_OR_THIS_CALL ~_Sentry_base()
{ // destroy after unlocking
if (_Myistr.rdbuf() != 0)
_Myistr.rdbuf()->_Unlock();
}

_Myt& _Myistr; // the input stream, for _Unlock call at destruction
};

class sentry
: public _Sentry_base
{ // stores thread lock and result of _Ipfx call
public:
explicit __CLR_OR_THIS_CALL sentry(_Myt& _Istr, bool _Noskip = false)
: _Sentry_base(_Istr)
{ // construct locking and calling _Ipfx
_Ok = this->_Myistr._Ipfx(_Noskip);
}

__CLR_OR_THIS_CALL operator bool() const
{ // test if _Ipfx succeeded
return (_Ok);
}

private:
__CLR_OR_THIS_CALL sentry(const sentry&); // not defined
sentry& __CLR_OR_THIS_CALL operator=(const sentry&); // not defined

bool _Ok; // true if _Ipfx succeeded at construction
};

bool __CLR_OR_THIS_CALL _Ipfx(bool _Noskip = false)
{ // test stream state and skip whitespace as needed
if (ios_base::good())
{ // state okay, flush tied stream and skip whitespace
if (_Myios::tie() != 0)
_Myios::tie()->flush();

if (!_Noskip && ios_base::flags() & ios_base::skipws)
{ // skip whitespace
const _Ctype& _Ctype_fac = _USE(ios_base::getloc(), _Ctype);

_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();

for (; ; _Meta = _Myios::rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_Myios::setstate(ios_base::eofbit)

;
break;
}
else if (!_Ctype_fac.is(_Ctype::space,
_Traits::to_char_type(_Meta)))
break; // not whitespace, quit
_CATCH_IO_END
}

if (ios_base::good())
return (true);
}
_Myios::setstate(ios_base::failbit);
return (false);
}

bool __CLR_OR_THIS_CALL ipfx(bool _Noskip = false)
{ // test stream state and skip whitespace as needed (retained)
return _Ipfx(_Noskip);
}

void __CLR_OR_THIS_CALL isfx()
{ // perform any wrapup (retained)
}

#ifdef _M_CEE_PURE
_Myt& __CLR_OR_THIS_CALL operator>>(_Myt& (__clrcall *_Pfn)(_Myt&))
{ // call basic_istream manipulator
_DEBUG_POINTER(_Pfn);
return ((*_Pfn)(*this));
}

_Myt& __CLR_OR_THIS_CALL operator>>(_Myios& (__clrcall *_Pfn)(_Myios&))
{ // call basic_ios manipulator
_DEBUG_POINTER(_Pfn);
(*_Pfn)(*(_Myios *)this);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(ios_base& (__clrcall *_Pfn)(ios_base&))
{ // call ios_base manipulator
_DEBUG_POINTER(_Pfn);
(*_Pfn)(*(ios_base *)this);
return (*this);
}
#endif

_Myt& __CLR_OR_THIS_CALL operator>>(_Myt& (__cdecl *_Pfn)(_Myt&))
{ // call basic_istream manipulator
_DEBUG_POINTER(_Pfn);
return ((*_Pfn)(*this));
}

_Myt& __CLR_OR_THIS_CALL operator>>(_Myios& (__cdecl *_Pfn)(_Myios&))
{ // call basic_ios manipulator
_DEBUG_POINTER(_Pfn);
(*_Pfn)(*(_Myios *)this);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(ios_base& (__cdecl *_Pfn)(ios_base&))
{ // call ios_base manipulator
_DEBUG_POINTER(_Pfn);
(*_Pfn)(*(ios_base *)this);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(_Bool& _Val)
{ // extract a boolean
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(short& _Val)
{ // extract a short
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
long _Tmp = 0;
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Tmp);
_CATCH_IO_END

if (_State & ios_base::failbit
|| _Tmp < SHRT_MIN || SHRT_MAX < _Tmp)
_State |= ios_base::failbit;
else
_Val = (short)_Tmp;
}

_Myios::setstate(_State);
return (*this);
}

/* Note that if your stream is wchar_t, and you are not using native wchar_t
Then this operation will be unavailable as there is an explicit
specialisation further down this file that is designed to treat an
unsigned short as a ch

aracter.

If you wish to read or write unsigned shorts to wchar_t streams, you should
consider making wchar_t a native type by turning on /Zc:wchar_t
*/
_Myt& __CLR_OR_THIS_CALL operator>>(unsigned short& _Val)
{ // extract an unsigned short
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(int& _Val)
{ // extract an int
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
long _Tmp = 0;
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Tmp);
_CATCH_IO_END

if (_State & ios_base::failbit
|| _Tmp < INT_MIN || INT_MAX < _Tmp)
_State |= ios_base::failbit;
else
_Val = _Tmp;
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(unsigned int& _Val)
{ // extract an unsigned int
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(long& _Val)
{ // extract a long
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);
_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(unsigned long __w64& _Val)
{ // extract an unsigned long
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

#ifdef _LONGLONG
_Myt& __CLR_OR_THIS_CALL operator>>(_LONGLONG& _Val)
{ // extract a long long
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbu

f()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(_ULONGLONG& _Val)
{ // extract an unsigned long long
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}
#endif /* _LONGLONG */

_Myt& __CLR_OR_THIS_CALL operator>>(float& _Val)
{ // extract a float
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(double& _Val)
{ // extract a double
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(long double& _Val)
{ // extract a long double
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);
_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(void *& _Val)
{ // extract a void pointer
ios_base::iostate _State = ios_base::goodbit;
const sentry _Ok(*this);

if (_Ok)
{ // state okay, use facet to extract
const _Nget& _Nget_fac = _USE(ios_base::getloc(), _Nget);

_TRY_IO_BEGIN
_Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
*this, _State, _Val);
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL operator>>(_Mysb *_Strbuf)
{ // extract until end-of-file into a stream buffer
ios_base::iostate _State = ios_base::goodbit;
bool _Copied = false;
const sentry _Ok(*this);

if (_Ok && _Strbuf != 0)
{ // state okay, extract characters
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();

for (; ; _Meta = _Myios::rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else
{ // got a char

acter, insert it into buffer
_TRY_BEGIN
if (_Traits::eq_int_type(_Traits::eof(),
_Strbuf->sputc(_Traits::to_char_type(_Meta))))
break;
_CATCH_ALL
break;
_CATCH_END
_Copied = true;
}
_CATCH_IO_END
}

_Myios::setstate(!_Copied ? _State | ios_base::failbit : _State);
return (*this);
}

int_type __CLR_OR_THIS_CALL get()
{ // extract a metacharacter
int_type _Meta = 0;
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (!_Ok)
_Meta = _Traits::eof(); // state not okay, return EOF
else
{ // state okay, extract a character
_TRY_IO_BEGIN
_Meta = _Myios::rdbuf()->sbumpc();

if (_Traits::eq_int_type(_Traits::eof(), _Meta))
_State |= ios_base::eofbit | ios_base::failbit; // end of file
else
++_Chcount; // got a character, count it
_CATCH_IO_END
}

_Myios::setstate(_State);
return (_Meta);
}

_Myt& __CLR_OR_THIS_CALL get(_Elem *_Str, streamsize _Count)
{ // get up to _Count characters into NTCS
return (get(_Str, _Count, _Myios::widen('\n')));
}

_Myt& __CLR_OR_THIS_CALL get(_Elem *_Str,
streamsize _Count, _Elem _Delim)
{ // get up to _Count characters into NTCS, stop before _Delim
_DEBUG_POINTER(_Str);
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok && 0 < _Count)
{ // state okay, extract characters
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();

for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (_Traits::to_char_type(_Meta) == _Delim)
break; // got a delimiter, quit
else
{ // got a character, add it to string
*_Str++ = _Traits::to_char_type(_Meta);
++_Chcount;
}
_CATCH_IO_END
}

_Myios::setstate(_Chcount == 0
? _State | ios_base::failbit : _State);
*_Str = _Elem(); // add terminating null character
return (*this);
}

_Myt& __CLR_OR_THIS_CALL get(_Elem& _Ch)
{ // get a character
int_type _Meta = get();
if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
_Ch = _Traits::to_char_type(_Meta);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf)
{ // extract up to newline and insert into stream buffer
return (get(_Strbuf, _Myios::widen('\n')));
}

_Myt& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf, _Elem _Delim)
{ // extract up to delimiter and insert into stream buffer
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok)
{ // state okay, use facet to extract
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();

for (; ; _Meta = _Myios::rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ //

end of file, quit
_State |= ios_base::eofbit;
break;
}
else
{ // got a character, insert it into stream buffer
_TRY_BEGIN
_Elem _Ch = _Traits::to_char_type(_Meta);
if (_Ch == _Delim
|| _Traits::eq_int_type(_Traits::eof(),
_Strbuf.sputc(_Ch)))
break;
_CATCH_ALL
break;
_CATCH_END
++_Chcount;
}
_CATCH_IO_END
}

if (_Chcount == 0)
_State |= ios_base::failbit;
_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL getline(_Elem *_Str, streamsize _Count)
{ // get up to _Count characters into NTCS, discard newline
return (getline(_Str, _Count, _Myios::widen('\n')));
}

_Myt& __CLR_OR_THIS_CALL getline(_Elem *_Str,
streamsize _Count, _Elem _Delim)
{ // get up to _Count characters into NTCS, discard _Delim
_DEBUG_POINTER(_Str);
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok && 0 < _Count)
{ // state okay, use facet to extract
int_type _Metadelim = _Traits::to_int_type(_Delim);

_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();

for (; ; _Meta = _Myios::rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (_Meta == _Metadelim)
{ // got a delimiter, discard it and quit
++_Chcount;
_Myios::rdbuf()->sbumpc();
break;
}
else if (--_Count <= 0)
{ // buffer full, quit
_State |= ios_base::failbit;
break;
}
else
{ // got a character, add it to string
++_Chcount;
*_Str++ = _Traits::to_char_type(_Meta);
}
_CATCH_IO_END
}

*_Str = _Elem(); // add terminating null character
_Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL ignore(streamsize _Count = 1,
int_type _Metadelim = _Traits::eof())
{ // ignore up to _Count characters, discarding delimiter
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok && 0 < _Count)
{ // state okay, use facet to extract
_TRY_IO_BEGIN
for (; ; )
{ // get a metacharacter if more room in buffer
int_type _Meta;
if (_Count != INT_MAX && --_Count < 0)
break; // buffer full, quit
else if (_Traits::eq_int_type(_Traits::eof(),
_Meta = _Myios::rdbuf()->sbumpc()))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else
{ // got a character, count it
++_Chcount;
if (_Meta == _Metadelim)
break; // got a delimiter, quit
}
}
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL _Read_s(_Elem *_Str, size_t _Str_size, streamsize _Count)
{ // read up to _Count characters i

nto buffer
_DEBUG_POINTER(_Str);
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok)
{ // state okay, use facet to extract
_TRY_IO_BEGIN
const streamsize _Num = _Myios::rdbuf()->_Sgetn_s(_Str, _Str_size, _Count);
_Chcount += _Num;
if (_Num != _Count)
_State |= ios_base::eofbit | ios_base::failbit; // short read
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL read(_Elem *_Str, streamsize _Count)
{
return _Read_s(_Str, (size_t)-1, _Count);
}

streamsize __CLR_OR_THIS_CALL _Readsome_s(_Elem *_Str, size_t _Str_size, streamsize _Count)
{ // read up to _Count characters into buffer, without blocking
_DEBUG_POINTER(_Str);
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
streamsize _Num;

if (!_Ok)
_State |= ios_base::failbit; // no buffer, fail
else if ((_Num = _Myios::rdbuf()->in_avail()) < 0)
_State |= ios_base::eofbit; // no characters available
else if (0 < _Num)
_Read_s(_Str, _Str_size, _Num < _Count ? _Num : _Count); // read available

_Myios::setstate(_State);
return (gcount());
}

_SCL_INSECURE_DEPRECATE
streamsize __CLR_OR_THIS_CALL readsome(_Elem *_Str, streamsize _Count)
{
return _Readsome_s(_Str, (size_t)-1, _Count);
}

int_type __CLR_OR_THIS_CALL peek()
{ // return next character, unconsumed
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
int_type _Meta = 0;
const sentry _Ok(*this, true);

if (!_Ok)
_Meta = _Traits::eof(); // state not okay, return EOF
else
{ // state okay, read a character
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(),
_Meta = _Myios::rdbuf()->sgetc()))
_State |= ios_base::eofbit;
_CATCH_IO_END
}

_Myios::setstate(_State);
return (_Meta);
}

_Myt& __CLR_OR_THIS_CALL putback(_Elem _Ch)
{ // put back a character
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok)
{ // state okay, put character back
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(),
_Myios::rdbuf()->sputbackc(_Ch)))
_State |= ios_base::badbit;
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

_Myt& __CLR_OR_THIS_CALL unget()
{ // put back last read character
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);

if (_Ok)
{ // state okay, use facet to extract
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(),
_Myios::rdbuf()->sungetc()))
_State |= ios_base::badbit;
_CATCH_IO_END
}

_Myios::setstate(_State);
return (*this);
}

streamsize __CLR_OR_THIS_CALL gcount() const
{ // get count from last extraction
return (_Chcount);
}

int __CLR_OR_THIS_CALL sync()
{ // synchronize

with input source
ios_base::iostate _State = ios_base::goodbit;
int _Ans;

if (_Myios::rdbuf() == 0)
_Ans = -1; // no buffer, fail
else if (_Myios::rdbuf()->pubsync() == -1)
{ // stream buffer sync failed, fail
_State |= ios_base::badbit;
_Ans = -1;
}
else
_Ans = 0; // success

_Myios::setstate(_State);
return (_Ans);
}

_Myt& __CLR_OR_THIS_CALL seekg(pos_type _Pos)
{ // set input stream position to _Pos
if (!ios_base::fail()
&& (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
ios_base::in) == _BADOFF)
_Myios::setstate(ios_base::failbit);
else
_Myios::clear(); // clear eofbit if set
return (*this);
}

_Myt& __CLR_OR_THIS_CALL seekg(off_type _Off, ios_base::seekdir _Way)
{ // change input stream position by _Off, according to _Way
if (!ios_base::fail()
&& (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
ios_base::in) == _BADOFF)
_Myios::setstate(ios_base::failbit);
else
_Myios::clear(); // clear eofbit if set
return (*this);
}

pos_type __CLR_OR_THIS_CALL tellg()
{ // return input stream position
if (!ios_base::fail())
return (_Myios::rdbuf()->pubseekoff(0,
ios_base::cur, ios_base::in));
else
return (pos_type(_BADOFF));
}

private:
streamsize _Chcount; // the character count
};

#ifndef _NATIVE_WCHAR_T_DEFINED
/*
This explicit template specialisation reads a single unicode character from the stream.

By default, the compiler treats wchar_t as if it were a typedef for unsigned short. This means
that we cannot distinguish between an unsigned short and a wchar_t in the library. To be most
consistent with previous practice, we add this explicit specialisation to ensure that a single
unsigned short is read and written as a character.

If you wish to read and write unsigned shorts as integers, we recommend you consider making
wchar_t a native type by using the /Zc:wchar_t compiler switch.
*/
template <> inline
basic_istream >&__CLR_OR_THIS_CALL
basic_istream >::operator>>(
unsigned short& _Ch)
{ // extract a character
typedef basic_istream > _Myis;
typedef char_traits _Traits;
_Myis::int_type _Meta;
_Myis &_Istr=*this;
ios_base::iostate _State = ios_base::goodbit;
const _Myis::sentry _Ok(_Istr);

if (_Ok)
{ // state okay, extract characters
_TRY_IO_BEGIN
_Meta = _Istr.rdbuf()->sbumpc();
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
_State |= ios_base::eofbit | ios_base::failbit; // end of file
else
_Ch = _Traits::to_char_type(_Meta); // got a character
_CATCH_IO_(_Istr)
}

_Istr.setstate(_State);
return (_Istr);
}
#endif

#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)

template class _CRTIMP2_PURE basic_istream >;
template class _CRTIMP2_PURE ba

sic_istream >;



#endif /* _DLL_CPPLIB */

// TEMPLATE CLASS basic_iostream
templateclass _Traits>
class basic_iostream
: public basic_istream<_Elem, _Traits>,
public basic_ostream<_Elem, _Traits>
{ // control insertions and extractions from a stream buffer
public:
typedef _Elem char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;

explicit __CLR_OR_THIS_CALL basic_iostream(basic_streambuf<_Elem, _Traits> *_Strbuf)
: basic_istream<_Elem, _Traits>(_Strbuf, false),
basic_ostream<_Elem, _Traits>(_Noinit, false)
{ // construct from stream buffer pointer
}

virtual __CLR_OR_THIS_CALL ~basic_iostream()
{ // destroy the object
}
};

#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)

template class _CRTIMP2_PURE basic_iostream >;
template class _CRTIMP2_PURE basic_iostream >;



#endif /* _DLL_CPPLIB */

// EXTRACTORS
templateclass _Traits> inline
basic_istream<_Elem, _Traits>& __CLRCALL_OR_CDECL operator>>(
basic_istream<_Elem, _Traits>& _Istr, _Elem *_Str)
{ // extract NTBS
_DEBUG_POINTER(_Str);
typedef basic_istream<_Elem, _Traits> _Myis;
typedef ctype<_Elem> _Ctype;
ios_base::iostate _State = ios_base::goodbit;
_Elem *_Str0 = _Str;
const typename _Myis::sentry _Ok(_Istr);

if (_Ok)
{ // state okay, extract characters
const _Ctype& _Ctype_fac = _USE(_Istr.getloc(), _Ctype);

_TRY_IO_BEGIN
streamsize _Count = 0 < _Istr.width() ? _Istr.width() : INT_MAX;
typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
_Elem _Ch;
for (; 0 < --_Count; _Meta = _Istr.rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (_Ctype_fac.is(_Ctype::space,
_Ch = _Traits::to_char_type(_Meta))
|| _Ch == _Elem())
break; // whitespace or nul, quit
else
*_Str++ = _Traits::to_char_type(_Meta); // add it to string
_CATCH_IO_(_Istr)
}

*_Str = _Elem(); // add terminating null character
_Istr.width(0);
_Istr.setstate(_Str == _Str0 ? _State | ios_base::failbit : _State);
return (_Istr);
}

templateclass _Traits> inline
basic_istream<_Elem, _Traits>& __CLRCALL_OR_CDECL operator>>(
basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch)
{ // extract a character
typedef basic_istream<_Elem, _Traits> _Myis;
typename _Myis::int_type _Meta;
ios_base::iostate _State = ios_base::goodbit;
const typename _Myis::sentry _Ok(_Istr);

if (_Ok)
{ // state okay, extract characters
_TRY_IO_BEGIN
_Meta = _Istr.rdbuf()->sbumpc();
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
_State |= ios_base::eofbit | ios_base::failbit; // end of file
else
_Ch

= _Traits::to_char_type(_Meta); // got a character
_CATCH_IO_(_Istr)
}

_Istr.setstate(_State);
return (_Istr);
}

#ifdef _MSC_VER
template inline
basic_istream& __CLRCALL_OR_CDECL operator>>(
basic_istream& _Istr, signed char *_Str)
{ // extract a signed char NTBS
return (_Istr >> (char *)_Str);
}

template inline
basic_istream& __CLRCALL_OR_CDECL operator>>(
basic_istream& _Istr, signed char& _Ch)
{ // extract a signed char
return (_Istr >> (char&)_Ch);
}

template inline
basic_istream& __CLRCALL_OR_CDECL operator>>(
basic_istream& _Istr, unsigned char *_Str)
{ // extract an unsigned char NTBS
return (_Istr >> (char *)_Str);
}

template inline
basic_istream& __CLRCALL_OR_CDECL operator>>(
basic_istream& _Istr, unsigned char& _Ch)
{ // extract an unsigned char
return (_Istr >> (char&)_Ch);
}

#endif

// MANIPULATORS
templateclass _Traits> inline
basic_istream<_Elem, _Traits>&
__CLRCALL_OR_CDECL ws(basic_istream<_Elem, _Traits>& _Istr)
{ // consume whitespace
typedef basic_istream<_Elem, _Traits> _Myis;
typedef ctype<_Elem> _Ctype;

if (!_Istr.eof())
{ // not at eof, okay to construct sentry and skip
ios_base::iostate _State = ios_base::goodbit;
const typename _Myis::sentry _Ok(_Istr, true);

if (_Ok)
{ // state okay, extract characters
const _Ctype& _Ctype_fac = _USE(_Istr.getloc(), _Ctype);

_TRY_IO_BEGIN
for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
_Meta = _Istr.rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (!_Ctype_fac.is(_Ctype::space,
_Traits::to_char_type(_Meta)))
break; // not whitespace, quit
_CATCH_IO_(_Istr)
}

_Istr.setstate(_State);
}
return (_Istr);
}

_CRTIMP2_PURE inline basic_istream >&
__CLRCALL_OR_CDECL ws(basic_istream >& _Istr)
{ // consume whitespace
typedef char _Elem;
typedef char_traits<_Elem> _Traits;

if (!_Istr.eof())
{ // not at eof, okay to construct sentry and skip
ios_base::iostate _State = ios_base::goodbit;
const basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);

if (_Ok)
{ // state okay, use facet to extract
const ctype<_Elem>& _Ctype_fac =
_USE(_Istr.getloc(), ctype<_Elem>);

_TRY_IO_BEGIN
for (_Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
_Meta = _Istr.rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (!_Ctype_fac.is(ctype<_Elem>::space,
_Traits::to_char_type(_Meta)))
break; // not

whitespace, quit
_CATCH_IO_(_Istr)
}

_Istr.setstate(_State);
}
return (_Istr);
}

_CRTIMP2_PURE inline basic_istream >&
__CLRCALL_OR_CDECL ws(basic_istream >& _Istr)
{ // consume whitespace
typedef wchar_t _Elem;
typedef char_traits<_Elem> _Traits;

if (!_Istr.eof())
{ // not at eof, okay to construct sentry and skip
ios_base::iostate _State = ios_base::goodbit;
const basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);

if (_Ok)
{ // state okay, use facet to extract
const ctype<_Elem>& _Ctype_fac =
_USE(_Istr.getloc(), ctype<_Elem>);

_TRY_IO_BEGIN
for (_Traits::int_type _Meta = _Istr.rdbuf()->sgetc(); ;
_Meta = _Istr.rdbuf()->snextc())
if (_Traits::eq_int_type(_Traits::eof(), _Meta))
{ // end of file, quit
_State |= ios_base::eofbit;
break;
}
else if (!_Ctype_fac.is(ctype<_Elem>::space,
_Traits::to_char_type(_Meta)))
break; // not whitespace, quit
_CATCH_IO_(_Istr)
}

_Istr.setstate(_State);
}
return (_Istr);
}



#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, char *);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, char&);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, signed char *);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, signed char&);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, unsigned char *);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, unsigned char&);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, wchar_t *);
template _CRTIMP2_PURE basic_istream >& __CLRCALL_OR_CDECL
operator>>(basic_istream >&, wchar_t&);



#endif /* _DLL_CPPLIB */
_STD_END

#ifdef _MSC_VER
#pragma warning(pop)
#pragma pack(pop)
#endif /* _MSC_VER */

#endif /* RC_INVOKED */
#endif /* _ISTREAM_ */

/*
* Copyright (c) 1992-2006 by P.J. Plauger. ALL RIGHTS RESERVED.
* Consult your license regarding permissions and restrictions.
V5.02:0009 */

相关文档