Inheritance diagram for basic_ostream< _Elem, _Traits >:

Classes
class	_Sentry_base

class	sentry

Public Types
typedef basic_ostream< _Elem, _Traits >	_Myt

typedef basic_ios< _Elem, _Traits >	_Myios

typedef basic_streambuf< _Elem, _Traits >	_Mysb

typedef ostreambuf_iterator< _Elem, _Traits >	_Iter

typedef num_put< _Elem, _Iter >	_Nput

typedef _Traits::int_type	int_type

typedef _Traits::pos_type	pos_type

typedef _Traits::off_type	off_type

Public Types inherited from basic_ios< _Elem, _Traits >
typedef basic_ios< _Elem, _Traits >	_Myt

typedef basic_ostream< _Elem, _Traits >	_Myos

typedef basic_streambuf< _Elem, _Traits >	_Mysb

typedef ctype< _Elem >	_Ctype

typedef _Elem	char_type

typedef _Traits	traits_type

typedef _Traits::int_type	int_type

typedef _Traits::pos_type	pos_type

typedef _Traits::off_type	off_type

Public Types inherited from ios_base
enum	event { erase_event, imbue_event, copyfmt_event }

typedef void(__CLRCALL_OR_CDECL *	event_callback) (event, ios_base &, int)

Public Types inherited from _Iosb< int >
enum	_Dummy_enum

enum	_Fmtflags

enum	_Iostate

enum	_Openmode

enum	_Seekdir

enum

Public Member Functions
__CLR_OR_THIS_CALL	basic_ostream (basic_streambuf< _Elem, _Traits > *_Strbuf, bool _Isstd=false)

__CLR_OR_THIS_CALL	basic_ostream (_Uninitialized, bool _Addit=true)

__CLR_OR_THIS_CALL	basic_ostream (const _Myt &)=delete

_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &)=delete

virtual __CLR_OR_THIS_CALL	~basic_ostream () _NOEXCEPT

bool __CLR_OR_THIS_CALL	opfx ()

void __CLR_OR_THIS_CALL	osfx ()

void __CLR_OR_THIS_CALL	_Osfx ()

_Myt &__CLR_OR_THIS_CALL	operator<< (_Myt &(__cdecl *_Pfn)(_Myt &))

_Myt &__CLR_OR_THIS_CALL	operator<< (_Myios &(__cdecl *_Pfn)(_Myios &))

_Myt &__CLR_OR_THIS_CALL	operator<< (ios_base &(__cdecl *_Pfn)(ios_base &))

_Myt &__CLR_OR_THIS_CALL	operator<< (bool _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (short _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned short _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (int _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned int _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (long _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned long _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (long long _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned long long _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (float _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (double _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (long double _Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (const void *_Val)

_Myt &__CLR_OR_THIS_CALL	operator<< (_Mysb *_Strbuf)

_Myt &__CLR_OR_THIS_CALL	put (_Elem _Ch)

_Myt &__CLR_OR_THIS_CALL	write (const _Elem *_Str, streamsize _Count)

_Myt &__CLR_OR_THIS_CALL	flush ()

_Myt &__CLR_OR_THIS_CALL	seekp (pos_type _Pos)

_Myt &__CLR_OR_THIS_CALL	seekp (off_type _Off, ios_base::seekdir _Way)

pos_type __CLR_OR_THIS_CALL	tellp ()

template<>
basic_ostream< unsigned short, char_traits< unsigned short > > &__CLR_OR_THIS_CALL	operator<< (unsigned short _Ch)

Public Member Functions inherited from basic_ios< _Elem, _Traits >
__CLR_OR_THIS_CALL	basic_ios (_Mysb *_Strbuf)

virtual __CLR_OR_THIS_CALL	~basic_ios () _NOEXCEPT

void __CLR_OR_THIS_CALL	clear (iostate _State=goodbit, bool _Reraise=false)

void __CLR_OR_THIS_CALL	setstate (iostate _State, bool _Reraise=false)

_Myt &__CLR_OR_THIS_CALL	copyfmt (const _Myt &_Right)

_Myos *__CLR_OR_THIS_CALL	tie () const

_Myos *__CLR_OR_THIS_CALL	tie (_Myos *_Newtie)

_Mysb *__CLR_OR_THIS_CALL	rdbuf () const

_Mysb *__CLR_OR_THIS_CALL	rdbuf (_Mysb *_Strbuf)

locale __CLR_OR_THIS_CALL	imbue (const locale &_Loc)

_Elem __CLR_OR_THIS_CALL	fill () const

_Elem __CLR_OR_THIS_CALL	fill (_Elem _Newfill)

char __CLR_OR_THIS_CALL	narrow (_Elem _Ch, char _Dflt= '\0') const

_Elem __CLR_OR_THIS_CALL	widen (char _Byte) const

void __CLR_OR_THIS_CALL	move (_Myt &_Right)

void __CLR_OR_THIS_CALL	move (_Myt &&_Right)

void __CLR_OR_THIS_CALL	swap (_Myt &_Right) _NOEXCEPT

void __CLR_OR_THIS_CALL	set_rdbuf (_Mysb *_Strbuf)

__CLR_OR_THIS_CALL	basic_ios (const _Myt &)=delete

_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &)=delete

Public Member Functions inherited from ios_base
	_IOS_BITMASK (_Fmtflags, fmtflags)

	_IOS_BITMASK (_Iostate, iostate)

	_IOS_BITMASK (_Openmode, openmode)

	_IOS_BITMASK (_Seekdir, seekdir)

__CLR_OR_THIS_CALL	operator bool () const

bool __CLR_OR_THIS_CALL	operator! () const

void __CLR_OR_THIS_CALL	clear (iostate _State, bool _Reraise)

void __CLR_OR_THIS_CALL	clear (iostate _State=goodbit)

iostate __CLR_OR_THIS_CALL	rdstate () const

void __CLR_OR_THIS_CALL	setstate (iostate _State, bool _Exreraise)

void __CLR_OR_THIS_CALL	setstate (iostate _State)

bool __CLR_OR_THIS_CALL	good () const

bool __CLR_OR_THIS_CALL	eof () const

bool __CLR_OR_THIS_CALL	fail () const

bool __CLR_OR_THIS_CALL	bad () const

iostate __CLR_OR_THIS_CALL	exceptions () const

void __CLR_OR_THIS_CALL	exceptions (iostate _Newexcept)

fmtflags __CLR_OR_THIS_CALL	flags () const

fmtflags __CLR_OR_THIS_CALL	flags (fmtflags _Newfmtflags)

fmtflags __CLR_OR_THIS_CALL	setf (fmtflags _Newfmtflags)

fmtflags __CLR_OR_THIS_CALL	setf (fmtflags _Newfmtflags, fmtflags _Mask)

void __CLR_OR_THIS_CALL	unsetf (fmtflags _Mask)

streamsize __CLR_OR_THIS_CALL	precision () const

streamsize __CLR_OR_THIS_CALL	precision (streamsize _Newprecision)

streamsize __CLR_OR_THIS_CALL	width () const

streamsize __CLR_OR_THIS_CALL	width (streamsize _Newwidth)

locale __CLR_OR_THIS_CALL	getloc () const

locale __CLR_OR_THIS_CALL	imbue (const locale &_Loc)

long &__CLR_OR_THIS_CALL	iword (int _Idx)

void *&__CLR_OR_THIS_CALL	pword (int _Idx)

void __CLR_OR_THIS_CALL	register_callback (event_callback _Pfn, int _Idx)

ios_base &__CLR_OR_THIS_CALL	copyfmt (const ios_base &_Other)

void __CLR_OR_THIS_CALL	swap (ios_base &_Right)

virtual __CLR_OR_THIS_CALL	~ios_base () _NOEXCEPT

	ios_base (const ios_base &)=delete

ios_base &	operator= (const ios_base &)=delete

Protected Member Functions
__CLR_OR_THIS_CALL	basic_ostream (_Myt &&_Right)

_Myt &__CLR_OR_THIS_CALL	operator= (_Myt &&_Right)

void __CLR_OR_THIS_CALL	swap (_Myt &_Right)

Protected Member Functions inherited from basic_ios< _Elem, _Traits >
void __CLR_OR_THIS_CALL	init (_Mysb *_Strbuf=0, bool _Isstd=false)

__CLR_OR_THIS_CALL	basic_ios ()

Protected Member Functions inherited from ios_base
__CLR_OR_THIS_CALL	ios_base ()

void __CLR_OR_THIS_CALL	_Init ()

Additional Inherited Members
Static Public Member Functions inherited from ios_base
static int __CLRCALL_OR_CDECL	xalloc ()

static bool __CLRCALL_OR_CDECL	sync_with_stdio (bool _Newsync=true)

static _MRTIMP2_PURE_NPURE void __CLRCALL_PURE_OR_CDECL	_Addstd (ios_base *)

Public Attributes inherited from ios_base
size_t	_Stdstr

Static Public Attributes inherited from _Iosb< int >
static constexpr _Fmtflags	skipws

static constexpr _Fmtflags	unitbuf

static constexpr _Fmtflags	uppercase

static constexpr _Fmtflags	showbase

static constexpr _Fmtflags	showpoint

static constexpr _Fmtflags	showpos

static constexpr _Fmtflags	left

static constexpr _Fmtflags	right

static constexpr _Fmtflags	internal

static constexpr _Fmtflags	dec

static constexpr _Fmtflags	oct

static constexpr _Fmtflags	hex

static constexpr _Fmtflags	scientific

static constexpr _Fmtflags	fixed

static constexpr _Fmtflags	hexfloat

static constexpr _Fmtflags	boolalpha

static constexpr _Fmtflags	_Stdio

static constexpr _Fmtflags	adjustfield

static constexpr _Fmtflags	basefield

static constexpr _Fmtflags	floatfield

static constexpr _Iostate	goodbit

static constexpr _Iostate	eofbit

static constexpr _Iostate	failbit

static constexpr _Iostate	badbit

static constexpr _Openmode	in

static constexpr _Openmode	out

static constexpr _Openmode	ate

static constexpr _Openmode	app

static constexpr _Openmode	trunc

static constexpr _Openmode	_Nocreate

static constexpr _Openmode	_Noreplace

static constexpr _Openmode	binary

static constexpr _Seekdir	beg

static constexpr _Seekdir	cur

static constexpr _Seekdir	end

Member Typedef Documentation

template<class _Elem, class _Traits>

typedef ostreambuf_iterator<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Iter

template<class _Elem, class _Traits>

typedef basic_ios<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Myios

template<class _Elem, class _Traits>

typedef basic_streambuf<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Mysb

template<class _Elem, class _Traits>

typedef basic_ostream<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Myt

template<class _Elem, class _Traits>

typedef num_put<_Elem, _Iter> basic_ostream< _Elem, _Traits >::_Nput

template<class _Elem, class _Traits>

typedef _Traits::int_type basic_ostream< _Elem, _Traits >::int_type

template<class _Elem, class _Traits>

typedef _Traits::off_type basic_ostream< _Elem, _Traits >::off_type

template<class _Elem, class _Traits>

typedef _Traits::pos_type basic_ostream< _Elem, _Traits >::pos_type

Constructor & Destructor Documentation

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream	(	basic_streambuf< _Elem, _Traits > *	_Strbuf,
		bool	_Isstd = `false`
	)

inlineexplicit

         {   // construct from a stream buffer pointer
         _Myios::init(_Strbuf, _Isstd);
         }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream	(	_Uninitialized	,
		bool	_Addit = `true`
	)

inline

         {   // construct uninitialized
         if (_Addit)
             this->_Addstd(this);    // suppress for basic_iostream
         }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( _Myt && _Right )

inlineprotected

         {   // construct by moving _Right
         _Myios::init();
         _Myios::move(_STD move(_Right));
         }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( const _Myt & )

delete

template<class _Elem, class _Traits>

virtual __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::~basic_ostream ( )

inlinevirtual

87 { // destroy the object

88 }

Member Function Documentation

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::_Osfx ( )

inline

         {   // perform any wrapup
         _TRY_BEGIN
         if (this->good() && this->flags() & ios_base::unitbuf)
             if (_Myios::rdbuf()->pubsync() == -1)   // flush stream as needed
                 _Myios::setstate(ios_base::badbit);
         _CATCH_ALL
         _CATCH_END
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::flush ( )

inline

         {   // flush output stream
         if (_Myios::rdbuf() != 0)
             {   // buffer exists, flush it
             const sentry _Ok(*this);
 
             if (_Ok && _Myios::rdbuf()->pubsync() == -1)
                 _Myios::setstate(ios_base::badbit); // sync failed
             }
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Myt & __cdecl *_Pfn)(_Myt & )

inline

         {   // call basic_ostream manipulator
         return ((*_Pfn)(*this));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Myios & __cdecl *_Pfn)(_Myios & )

inline

         {   // call basic_ios manipulator
         (*_Pfn)(*(_Myios *)this);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( ios_base & __cdecl *_Pfn)(ios_base & )

inline

         {   // call ios_base manipulator
         (*_Pfn)(*(ios_base *)this);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( bool _Val )

inline

         {   // insert a boolean
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( short _Val )

inline

         {   // insert a short
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
             ios_base::fmtflags _Bfl =
                 this->flags() & ios_base::basefield;
             long _Tmp = (_Bfl == ios_base::oct
                 || _Bfl == ios_base::hex)
                 ? (long)(unsigned short)_Val : (long)_Val;
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Tmp).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned short _Val )

inline

         {   // insert an unsigned short
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), (unsigned long)_Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( int _Val )

inline

         {   // insert an int
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
             ios_base::fmtflags _Bfl =
                 this->flags() & ios_base::basefield;
             long _Tmp = (_Bfl == ios_base::oct
                 || _Bfl == ios_base::hex)
                 ? (long)(unsigned int)_Val : (long)_Val;
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Tmp).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned int _Val )

inline

         {   // insert an unsigned int
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), (unsigned long)_Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( long _Val )

inline

         {   // insert a long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned long _Val )

inline

         {   // insert an unsigned long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( long long _Val )

inline

         {   // insert a long long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned long long _Val )

inline

         {   // insert an unsigned long long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( float _Val )

inline

         {   // insert a float
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), (double)_Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( double _Val )

inline

         {   // insert a double
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( long double _Val )

inline

         {   // insert a long double
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( const void * _Val )

inline

         {   // insert a void pointer
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to insert
             const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
 
             _TRY_IO_BEGIN
             if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                 _Myios::fill(), _Val).failed())
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Mysb * _Strbuf )

inline

         {   // insert until end-of-file from a stream buffer
         ios_base::iostate _State = ios_base::goodbit;
         bool _Copied = false;
         const sentry _Ok(*this);
 
         if (_Ok && _Strbuf != 0)
             for (int_type _Meta = _Traits::eof(); ; _Copied = true)
                 {   // extract another character from stream buffer
                 _TRY_BEGIN
                 _Meta = _Traits::eq_int_type(_Traits::eof(), _Meta)
                     ? _Strbuf->sgetc() : _Strbuf->snextc();
                 _CATCH_ALL
                     _Myios::setstate(ios_base::failbit);
                     _RERAISE;
                 _CATCH_END
 
                 if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                     break;  // end of file, quit
 
                 _TRY_IO_BEGIN
                     if (_Traits::eq_int_type(_Traits::eof(),
                         _Myios::rdbuf()->sputc(
                             _Traits::to_char_type(_Meta))))
                         {   // insertion failed, quit
                         _State |= ios_base::badbit;
                         break;
                         }
                 _CATCH_IO_END
                 }
 
         this->width(0);
         _Myios::setstate(_Strbuf == 0 ? ios_base::badbit
             : !_Copied ? _State | ios_base::failbit : _State);
         return (*this);
         }

template<>

basic_ostream< unsigned short, char_traits< unsigned short > > &__CLR_OR_THIS_CALL basic_ostream< unsigned short, char_traits< unsigned short > >::operator<< ( unsigned short _Ch )

inline

     {   // extract a character
     typedef char_traits<unsigned short> _Traits;
 
     ios_base::iostate _State = ios_base::goodbit;
     const sentry _Ok(*this);
 
     if (_Ok)
         {   // state okay, insert
         streamsize _Pad = this->width() <= 1 ? 0 : this->width() - 1;
 
         _TRY_IO_BEGIN
         if ((this->flags() & ios_base::adjustfield) != ios_base::left)
             for (; _State == ios_base::goodbit && 0 < _Pad;
                 --_Pad) // pad on left
                 if (_Traits::eq_int_type(_Traits::eof(),
                     this->rdbuf()->sputc(this->fill())))
                     _State |= ios_base::badbit;
 
         if (_State == ios_base::goodbit
             && _Traits::eq_int_type(_Traits::eof(),
                 this->rdbuf()->sputc(_Ch)))
             _State |= ios_base::badbit;
 
         for (; _State == ios_base::goodbit && 0 < _Pad;
             --_Pad) // pad on right
             if (_Traits::eq_int_type(_Traits::eof(),
                 this->rdbuf()->sputc(this->fill())))
                 _State |= ios_base::badbit;
         _CATCH_IO_END
         }
 
     this->width(0);
     _Myios::setstate(_State);
     return (*this);
     }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator= ( _Myt && _Right )

inlineprotected

         {   // move from _Right
         this->swap(_Right);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator= ( const _Myt & )

delete

template<class _Elem, class _Traits>

bool __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::opfx ( )

inline

         {   // test stream state and flush tie stream as needed (retained)
         if (this->good() && _Myios::tie() != 0 && _Myios::tie() != this)
             _Myios::tie()->flush();
         return (this->good());
         }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::osfx ( )

inline

         {   // perform any wrapup (retained)
         _Osfx();
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::put ( _Elem _Ch )

inline

         {   // insert a character
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (!_Ok)
             _State |= ios_base::badbit;
         else
             {   // state okay, insert character
             _TRY_IO_BEGIN
             if (_Traits::eq_int_type(_Traits::eof(),
                 _Myios::rdbuf()->sputc(_Ch)))
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::seekp ( pos_type _Pos )

inline

         {   // set output stream position to _Pos
         const sentry _Ok(*this);
 
         if (!this->fail()
             && (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
                 ios_base::out) == _BADOFF)
             _Myios::setstate(ios_base::failbit);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::seekp	(	off_type	_Off,
		ios_base::seekdir	_Way
	)

inline

         {   // change output stream position by _Off, according to _Way
         const sentry _Ok(*this);
 
         if (!this->fail()
             && (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
                 ios_base::out) == _BADOFF)
             _Myios::setstate(ios_base::failbit);
         return (*this);
         }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::swap ( _Myt & _Right )

inlineprotected

         {   // swap with _Right
         if (this != _STD addressof(_Right))
             _Myios::swap(_Right);
         }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::tellp ( )

inline

         {   // return output stream position
         const sentry _Ok(*this);
 
         if (!this->fail())
             return (_Myios::rdbuf()->pubseekoff(0,
                 ios_base::cur, ios_base::out));
         else
             return (pos_type(_BADOFF));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::write	(	const _Elem *	_Str,
		streamsize	_Count
	)

inline

         {   // insert _Count characters from array _Str
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (!_Ok)
             _State |= ios_base::badbit;
         else if (0 < _Count)
             {   // state okay, insert characters
             _TRY_IO_BEGIN
             if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count)
                 _State |= ios_base::badbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

The documentation for this class was generated from the following files:

VS2017/inc/iosfwd
VS2017/inc/ostream

Classes

Public Types

Public Member Functions

Protected Member Functions

Additional Inherited Members

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation