ostream File Reference

#include <ios>

Classes
class	basic_ostream< _Elem, _Traits >
class	basic_ostream< _Elem, _Traits >::_Sentry_base
class	basic_ostream< _Elem, _Traits >::sentry

Macros
#define	_OSTREAM_
#define	_TRY_IO_BEGIN   { /* begin try block */
#define	_CATCH_IO_END   } /* catch block for _Myios */
#define	_CATCH_IO_(x)   } /* catch block for basic_ios x */

Functions
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const char *_Val)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, char _Ch)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, const char *_Val)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, char _Ch)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Elem *_Val)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, _Elem _Ch)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, const signed char *_Val)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, signed char _Ch)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, const unsigned char *_Val)
template<class _Traits >
basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &_Ostr, unsigned char _Ch)
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &&_Ostr, const _Ty &_Val)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &__CLRCALL_OR_CDECL	endl (basic_ostream< _Elem, _Traits > &_Ostr)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &__CLRCALL_OR_CDECL	ends (basic_ostream< _Elem, _Traits > &_Ostr)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &__CLRCALL_OR_CDECL	flush (basic_ostream< _Elem, _Traits > &_Ostr)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const error_code &_Errcode)

Macro Definition Documentation

#define _CATCH_IO_

(

x

)

} /* catch block for basic_ios x */

#define _CATCH_IO_END   } /* catch block for _Myios */

#define _OSTREAM_

#define _TRY_IO_BEGIN   { /* begin try block */

Function Documentation

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL endl ( basic_ostream< _Elem, _Traits > &  _Ostr )

inline

    {   // insert newline and flush stream
    _Ostr.put(_Ostr.widen('\n'));
    _Ostr.flush();
    return (_Ostr);
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL ends ( basic_ostream< _Elem, _Traits > &  _Ostr )

inline

    {   // insert null character
    _Ostr.put(_Elem());
    return (_Ostr);
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL flush ( basic_ostream< _Elem, _Traits > &  _Ostr )

inline

    {   // flush stream
    _Ostr.flush();
    return (_Ostr);
    }

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, const char *  _Val  )

inline

    {   // insert NTBS into char stream
    typedef char _Elem;
    typedef basic_ostream<_Elem, _Traits> _Myos;
    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count = (streamsize)_Traits::length(_Val);  // may overflow
    streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
        ? 0 : _Ostr.width() - _Count;
    const typename _Myos::sentry _Ok(_Ostr);

    if (!_Ok)
        _State |= ios_base::badbit;
    else
        {   // state okay, insert
        _TRY_IO_BEGIN
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
            for (; 0 < _Pad; --_Pad)    // pad on left
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }

        if (_State == ios_base::goodbit
            && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
            _State |= ios_base::badbit;

        if (_State == ios_base::goodbit)
            for (; 0 < _Pad; --_Pad)    // pad on right
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }
        _Ostr.width(0);
        _CATCH_IO_(_Ostr)
        }

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

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, char  _Ch  )

inline

    {   // insert a character
    ios_base::iostate _State = ios_base::goodbit;
    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

    if (_Ok)
        {   // state okay, insert
        const ctype<_Elem>& _Ctype_fac = _USE(_Ostr.getloc(), ctype<_Elem>);
        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        _TRY_IO_BEGIN
        if ((_Ostr.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(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    _State |= ios_base::badbit;

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(),
                _Ostr.rdbuf()->sputc(_Ctype_fac.widen(_Ch))))
            _State |= ios_base::badbit;

        for (; _State == ios_base::goodbit && 0 < _Pad;
            --_Pad) // pad on right
            if (_Traits::eq_int_type(_Traits::eof(),
                _Ostr.rdbuf()->sputc(_Ostr.fill())))
                _State |= ios_base::badbit;
        _CATCH_IO_(_Ostr)
        }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return (_Ostr);
    }

template<class _Elem , class _Traits , class _Ty >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &&  _Ostr, const _Ty &  _Val  )

inline

    {   // insert to rvalue stream
    return (_Ostr << _Val);
    }

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, unsigned char  _Ch  )

inline

    {   // insert an unsigned char
    return (_Ostr << (char)_Ch);
    }

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, const unsigned char *  _Val  )

inline

    {   // insert an unsigned char NTBS
    return (_Ostr << (const char *)_Val);
    }

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, char  _Ch  )

inline

    {   // insert a char into char stream
    typedef char _Elem;
    typedef basic_ostream<_Elem, _Traits> _Myos;
    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok)
        {   // state okay, insert
        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        _TRY_IO_BEGIN
        if ((_Ostr.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(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    _State |= ios_base::badbit;

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(),
                _Ostr.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(),
                _Ostr.rdbuf()->sputc(_Ostr.fill())))
                _State |= ios_base::badbit;
        _CATCH_IO_(_Ostr)
        }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return (_Ostr);
    }

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, const signed char *  _Val  )

inline

    {   // insert a signed char NTBS
    return (_Ostr << (const char *)_Val);
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, _Elem  _Ch  )

inline

    {   // insert a character
    typedef basic_ostream<_Elem, _Traits> _Myos;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok)
        {   // state okay, insert
        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        _TRY_IO_BEGIN
        if ((_Ostr.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(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    _State |= ios_base::badbit;

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(),
                _Ostr.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(),
                _Ostr.rdbuf()->sputc(_Ostr.fill())))
                _State |= ios_base::badbit;
        _CATCH_IO_(_Ostr)
        }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return (_Ostr);
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, const _Elem *  _Val  )

inline

    {   // insert NTCS
    typedef basic_ostream<_Elem, _Traits> _Myos;

    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count = (streamsize)_Traits::length(_Val);  // may overflow
    streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
        ? 0 : _Ostr.width() - _Count;
    const typename _Myos::sentry _Ok(_Ostr);

    if (!_Ok)
        _State |= ios_base::badbit;
    else
        {   // state okay, insert
        _TRY_IO_BEGIN
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
            for (; 0 < _Pad; --_Pad)    // pad on left
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }

        if (_State == ios_base::goodbit
            && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
            _State |= ios_base::badbit;

        if (_State == ios_base::goodbit)
            for (; 0 < _Pad; --_Pad)    // pad on right
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }
        _Ostr.width(0);
        _CATCH_IO_(_Ostr)
        }

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

template<class _Traits >

basic_ostream<char, _Traits>& operator<< ( basic_ostream< char, _Traits > &  _Ostr, signed char  _Ch  )

inline

    {   // insert a signed char
    return (_Ostr << (char)_Ch);
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, const char *  _Val  )

inline

    {   // insert NTBS
    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count = (streamsize)_CSTD strlen(_Val); // may overflow
    streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
        ? 0 : _Ostr.width() - _Count;
    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

    if (!_Ok)
        _State |= ios_base::badbit;
    else
        {   // state okay, insert characters
        _TRY_IO_BEGIN
        const ctype<_Elem>& _Ctype_fac = _USE(_Ostr.getloc(), ctype<_Elem>);
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
            for (; 0 < _Pad; --_Pad)    // pad on left
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }

        for (; _State == ios_base::goodbit && 0 < _Count; --_Count, ++_Val)
            if (_Traits::eq_int_type(_Traits::eof(),
                _Ostr.rdbuf()->sputc(_Ctype_fac.widen(*_Val))))
                    _State |= ios_base::badbit;

        if (_State == ios_base::goodbit)
            for (; 0 < _Pad; --_Pad)    // pad on right
                if (_Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Ostr.fill())))
                    {   // insertion failed, quit
                    _State |= ios_base::badbit;
                    break;
                    }
        _Ostr.width(0);
        _CATCH_IO_(_Ostr)
        }

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

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, const error_code &  _Errcode  )

inline

    {   // display error code
    return (_Ostr << _Errcode.category().name() << ':' << _Errcode.value());
    }