xmemory File Reference

#include <xmemory0>

Classes
class	raw_storage_iterator< _OutIt, _Ty >
class	_Temp_iterator< _Ty >
struct	_Temp_iterator< _Ty >::_Bufpar
class	auto_ptr< _Ty >
struct	auto_ptr_ref< _Ty >
class	auto_ptr< _Ty >

Macros
#define	_XMEMORY_

Functions
template<class _Ty >
_STD_BEGIN pair< _Ty *, ptrdiff_t >	get_temporary_buffer (ptrdiff_t _Count) _NOEXCEPT
template<class _Ty >
void	return_temporary_buffer (_Ty *_Pbuf)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest, input_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest, forward_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest, _Scalar_ptr_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest)
template<class _InIt , class _FwdIt >
_FwdIt	_Uninitialized_copy0 (_InIt _First, _InIt _Last, _FwdIt _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt >
_FwdIt	_Uninitialized_copy0 (_InIt _First, _InIt _Last, _FwdIt _Dest, _Scalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt >
_FwdIt	_Uninitialized_copy0 (_InIt _First, _InIt _Last, _FwdIt _Dest)
template<class _InIt , class _FwdIt >
_FwdIt	uninitialized_copy (_InIt _First, _InIt _Last, _FwdIt _Dest)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninit_copy (_InIt _First, _InIt _Last, _FwdIt _Dest, _Wrap_alloc< _Alloc > &_Al, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninit_copy (_InIt _First, _InIt _Last, _FwdIt _Dest, _Wrap_alloc< _Alloc > &_Al, _Scalar_ptr_iterator_tag)
template<class _Ty1 , class _Ty2 >
_Ty2 *	_Uninit_copy (_Ty1 *_First, _Ty1 *_Last, _Ty2 *_Dest, _Wrap_alloc< allocator< _Ty2 > > &, _Scalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninit_copy (_InIt _First, _InIt _Last, _FwdIt _Dest, _Alloc &_Al)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninitialized_copy (_InIt _First, _InIt _Last, _FwdIt _Dest, _Alloc &_Al)
template<class _InIt , class _FwdIt , class _Alloc , class _Valty >
_FwdIt	_Uninit_move (_InIt _First, _InIt _Last, _FwdIt _Dest, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt , class _Alloc , class _Valty >
_FwdIt	_Uninit_move (_InIt _First, _InIt _Last, _FwdIt _Dest, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Scalar_ptr_iterator_tag)
template<class _Ty1 , class _Ty2 , class _Valty >
_Ty2 *	_Uninit_move (_Ty1 *_First, _Ty1 *_Last, _Ty2 *_Dest, _Wrap_alloc< allocator< _Ty2 > > &, _Valty *, _Scalar_ptr_iterator_tag)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninit_move (_InIt _First, _InIt _Last, _FwdIt _Dest, _Alloc &_Al)
template<class _InIt , class _FwdIt , class _Alloc >
_FwdIt	_Uninitialized_move (_InIt _First, _InIt _Last, _FwdIt _Dest, _Alloc &_Al)
template<class _FwdIt , class _Tval >
void	_Uninit_fill (_FwdIt _First, _FwdIt _Last, const _Tval &_Val, _Nonscalar_ptr_iterator_tag)
template<class _Ty , class _Tval >
void	_Uninit_fill (_Ty *_First, _Ty *_Last, const _Tval &_Val, _Scalar_ptr_iterator_tag)
template<class _FwdIt , class _Tval >
void	uninitialized_fill (_FwdIt _First, _FwdIt _Last, const _Tval &_Val)
template<class _FwdIt , class _Diff , class _Tval >
_FwdIt	_Uninit_fill_n (_FwdIt _First, _Diff _Count, const _Tval &_Val, _Nonscalar_ptr_iterator_tag)
template<class _Ty , class _Diff , class _Tval >
_Ty *	_Uninit_fill_n (_Ty *_First, _Diff _Count, const _Tval &_Val, _Scalar_ptr_iterator_tag)
template<class _FwdIt , class _Diff , class _Tval >
_FwdIt	uninitialized_fill_n (_FwdIt _First, _Diff _Count, const _Tval &_Val)
template<class _FwdIt , class _Diff , class _Tval , class _Alloc , class _Valty >
void	_Uninit_fill_n (_FwdIt _First, _Diff _Count, const _Tval *_Pval, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Nonscalar_ptr_iterator_tag)
template<class _FwdIt , class _Diff , class _Tval , class _Alloc , class _Valty >
void	_Uninit_fill_n (_FwdIt _First, _Diff _Count, const _Tval *_Pval, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Scalar_ptr_iterator_tag)
template<class _Ty , class _Diff , class _Tval , class _Valty >
void	_Uninit_fill_n (_Ty *_First, _Diff _Count, const _Tval *_Pval, _Wrap_alloc< allocator< _Ty > > &, _Valty *, _Scalar_ptr_iterator_tag)
template<class _FwdIt , class _Diff , class _Tval , class _Alloc >
void	_Uninitialized_fill_n (_FwdIt _First, _Diff _Count, const _Tval *_Pval, _Alloc &_Al)
template<class _FwdIt , class _Diff , class _Alloc , class _Valty >
void	_Uninit_def_fill_n (_FwdIt _First, _Diff _Count, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Nonscalar_ptr_iterator_tag)
template<class _FwdIt , class _Diff , class _Alloc , class _Valty >
void	_Uninit_def_fill_n (_FwdIt _First, _Diff _Count, _Wrap_alloc< _Alloc > &_Al, _Valty *, _Scalar_ptr_iterator_tag)
template<class _Ty , class _Diff , class _Valty >
void	_Uninit_def_fill_n (_Ty *_First, _Diff _Count, _Wrap_alloc< allocator< _Ty > > &, _Valty *, _Scalar_ptr_iterator_tag)
template<class _FwdIt , class _Diff , class _Alloc >
void	_Uninitialized_default_fill_n (_FwdIt _First, _Diff _Count, _Alloc &_Al)

Macro Definition Documentation

#define _XMEMORY_

Function Documentation

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninit_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Wrap_alloc< _Alloc > &  _Al, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw _Dest, using _Al, arbitrary type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; _First != _Last; ++_Dest, ++_First)
        _Al.construct(_Dest, *_First);
    _CATCH_ALL
    for (; _Next != _Dest; ++_Next)
        _Al.destroy(_Next);
    _RERAISE;
    _CATCH_END
    return (_Dest);
    }

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninit_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Wrap_alloc< _Alloc > &  _Al, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw _Dest, using _Al, scalar type
    return (_Uninit_copy(_First, _Last, _Dest,
        _Al, _Nonscalar_ptr_iterator_tag()));
    }

template<class _Ty1 , class _Ty2 >

_Ty2* _Uninit_copy ( _Ty1 *  _First, _Ty1 *  _Last, _Ty2 *  _Dest, _Wrap_alloc< allocator< _Ty2 > > &  , _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw _Dest, scalar type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    size_t _Count = (size_t)(_Last - _First);
    return ((_Ty2 *)_CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First)) + _Count);   // NB: non-overlapping move
    }

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninit_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Alloc &  _Al  )

inline

    {   // copy [_First, _Last) to raw _Dest, using _Al
    return (_Uninit_copy(_First, _Last, _Dest, _Al,
        _Ptr_cat(_First, _Dest)));
    }

template<class _FwdIt , class _Diff , class _Alloc , class _Valty >

void _Uninit_def_fill_n ( _FwdIt  _First, _Diff  _Count, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy _Count * _Valty() to raw _First, using _Al, arbitrary type
 #if _ITERATOR_DEBUG_LEVEL == 2
//  if (_Count < 0)
//      _DEBUG_ERROR("negative count in uninitialized fill");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, ++_First)

        _Al.construct(_First);

    _CATCH_ALL
    for (; _Next != _First; ++_Next)
        _Al.destroy(_Next);
    _RERAISE;
    _CATCH_END
    }

template<class _FwdIt , class _Diff , class _Alloc , class _Valty >

void _Uninit_def_fill_n ( _FwdIt  _First, _Diff  _Count, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Count * _Valty() to raw _First, using _Al, arbitrary type
    _Uninit_def_fill_n(_First, _Count,
        _Al, (_Valty *)0, _Nonscalar_ptr_iterator_tag());
    }

template<class _Ty , class _Diff , class _Valty >

void _Uninit_def_fill_n ( _Ty *  _First, _Diff  _Count, _Wrap_alloc< allocator< _Ty > > &  , _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Count * _Valty() to raw _First, using _Al, scalar type
    _Fill_n(_First, _Count, (_Valty)0);
    }

template<class _FwdIt , class _Tval >

void _Uninit_fill ( _FwdIt  _First, _FwdIt  _Last, const _Tval &  _Val, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy _Val throughout raw [_First, _Last), arbitrary type
    _DEBUG_RANGE(_First, _Last);
    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; _First != _Last; ++_First)
        _Construct(&*_First, _Val);
    _CATCH_ALL
    for (; _Next != _First; ++_Next)
        _Destroy(&*_Next);
    _RERAISE;
    _CATCH_END
    }

template<class _Ty , class _Tval >

void _Uninit_fill ( _Ty *  _First, _Ty *  _Last, const _Tval &  _Val, _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Val throughout raw [_First, _Last), scalar type
    _STD fill(_First, _Last, _Val);
    }

template<class _FwdIt , class _Diff , class _Tval >

_FwdIt _Uninit_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval &  _Val, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy _Count *_Val to raw _First, arbitrary type
 #if _ITERATOR_DEBUG_LEVEL == 2
//  if (_Count < 0)
//      _DEBUG_ERROR("negative count in uninitialized fill");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, ++_First)
        _Construct(&*_First, _Val);
    _CATCH_ALL
    for (; _Next != _First; ++_Next)
        _Destroy(&*_Next);
    _RERAISE;
    _CATCH_END

    return (_First);
    }

template<class _Ty , class _Diff , class _Tval >

_Ty* _Uninit_fill_n ( _Ty *  _First, _Diff  _Count, const _Tval &  _Val, _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Count *_Val to raw _First, scalar type
    return (_Fill_n(_First, _Count, _Val));
    }

template<class _FwdIt , class _Diff , class _Tval , class _Alloc , class _Valty >

void _Uninit_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval *  _Pval, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy _Count * *_Pval to raw _First, using _Al, arbitrary type
 #if _ITERATOR_DEBUG_LEVEL == 2
//  if (_Count < 0)
//      _DEBUG_ERROR("negative count in uninitialized fill");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, ++_First)
        _Al.construct(_First, *_Pval);
    _CATCH_ALL
    for (; _Next != _First; ++_Next)
        _Al.destroy(_Next);
    _RERAISE;
    _CATCH_END
    }

template<class _FwdIt , class _Diff , class _Tval , class _Alloc , class _Valty >

void _Uninit_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval *  _Pval, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Count * *_Pval to raw _First, using _Al, arbitrary type
    _Uninit_fill_n(_First, _Count,
        _Pval, _Al, (_Valty *)0, _Nonscalar_ptr_iterator_tag());
    }

template<class _Ty , class _Diff , class _Tval , class _Valty >

void _Uninit_fill_n ( _Ty *  _First, _Diff  _Count, const _Tval *  _Pval, _Wrap_alloc< allocator< _Ty > > &  , _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // copy _Count * *_Pval to raw _First, using _Al, scalar type
    _Fill_n(_First, _Count, *_Pval);
    }

template<class _InIt , class _FwdIt , class _Alloc , class _Valty >

_FwdIt _Uninit_move ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Nonscalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to raw _Dest, using _Al, arbitrary type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; _First != _Last; ++_Dest, ++_First)
        _Al.construct(_Dest, (_Valty&&)*_First);
    _CATCH_ALL
    for (; _Next != _Dest; ++_Next)
        _Al.destroy(_Next);
    _RERAISE;
    _CATCH_END
    return (_Dest);
    }

template<class _InIt , class _FwdIt , class _Alloc , class _Valty >

_FwdIt _Uninit_move ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Wrap_alloc< _Alloc > &  _Al, _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to raw _Dest, using _Al, scalar type
    return (_Uninit_move(_First, _Last, _Dest,
        _Al, (_Valty *)0, _Nonscalar_ptr_iterator_tag()));
    }

template<class _Ty1 , class _Ty2 , class _Valty >

_Ty2* _Uninit_move ( _Ty1 *  _First, _Ty1 *  _Last, _Ty2 *  _Dest, _Wrap_alloc< allocator< _Ty2 > > &  , _Valty *  , _Scalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to raw _Dest, scalar type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    size_t _Count = (size_t)(_Last - _First);
    return ((_Ty2 *)_CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First)) + _Count);   // NB: non-overlapping move
    }

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninit_move ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Alloc &  _Al  )

inline

    {   // move [_First, _Last) to raw _Dest, using _Al
    return (_Uninit_move(_First, _Last, _Dest, _Al,
        _Val_type(_First), _Ptr_cat(_First, _Dest)));
    }

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninitialized_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Alloc &  _Al  )

inline

    {   // copy [_First, _Last) to raw _Dest, using _Al
    return (_Rechecked(_Dest,
        _Uninit_copy(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest), _Al)));
    }

template<class _InIt , class _FwdIt >

_FwdIt _Uninitialized_copy0 ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...), arbitrary iterators
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; _First != _Last; ++_Dest, ++_First)
        _Construct(&*_Dest, *_First);
    _CATCH_ALL
    for (; _Next != _Dest; ++_Next)
        _Destroy(&*_Next);
    _RERAISE;
    _CATCH_END
    return (_Dest);
    }

template<class _InIt , class _FwdIt >

_FwdIt _Uninitialized_copy0 ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...), pointers to scalars
    ptrdiff_t _Count = _Last - _First;
    _CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First));
    return (_Dest + _Count);
    }

template<class _InIt , class _FwdIt >

_FwdIt _Uninitialized_copy0 ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest  )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...)
    return (_Uninitialized_copy0(_First, _Last,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, input_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), input iterators
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    _Construct(&*_Dest, *_First);   // 0 < _Count has been guaranteed
    while (0 < --_Count)
        _Construct(&*++_Dest, *++_First);
    _CATCH_ALL
    for (; _Next != _Dest; ++_Next)
        _Destroy(&*_Next);
    _RERAISE;
    _CATCH_END
    return (++_Dest);
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, forward_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), forward iterators
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, ++_Dest, ++_First)
        _Construct(&*_Dest, *_First);
    _CATCH_ALL
    for (; _Next != _Dest; ++_Next)
        _Destroy(&*_Next);
    _RERAISE;
    _CATCH_END
    return (_Dest);
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), arbitrary iterators
    return (_Uninitialized_copy_n(_First, _Count,
        _Dest, _Iter_cat(_First)));
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), pointers to scalars
    _CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First));
    return (_Dest + _Count);
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), unchecked
    return (_Uninitialized_copy_n(_First, _Count,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _FwdIt , class _Diff , class _Alloc >

void _Uninitialized_default_fill_n ( _FwdIt  _First, _Diff  _Count, _Alloc &  _Al  )

inline

    {   // copy _Count * _Val_type(_First)() to raw _First, using _Al
    _Uninit_def_fill_n(_First, _Count, _Al,
        _Val_type(_First), _Ptr_cat(_First, _First));
    }

template<class _FwdIt , class _Diff , class _Tval , class _Alloc >

void _Uninitialized_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval *  _Pval, _Alloc &  _Al  )

inline

    {   // copy _Count * *_Pval to raw _First, using _Al
    _Uninit_fill_n(_First, _Count, _Pval, _Al,
        _Val_type(_First), _Ptr_cat(_First, _First));
    }

template<class _InIt , class _FwdIt , class _Alloc >

_FwdIt _Uninitialized_move ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Alloc &  _Al  )

inline

    {   // move [_First, _Last) to raw _Dest, using _Al
    return (_Rechecked(_Dest,
        _Uninit_move(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest), _Al)));
    }

template<class _Ty >

_STD_BEGIN pair<_Ty *, ptrdiff_t> get_temporary_buffer ( ptrdiff_t  _Count )

inline

    {   // get raw temporary buffer of up to _Count elements
    _Ty *_Pbuf;

    if (_Count < 0)
        _Count = 0;
    else if (((size_t)(-1) / sizeof (_Ty) < _Count))
        _Xbad_alloc();  // report no memory
    for (_Pbuf = 0; 0 < _Count; _Count /= 2)
        if ((_Pbuf = (_Ty *)operator new(
            (size_t)_Count * sizeof (_Ty), nothrow)) != 0)
            break;

    return (pair<_Ty *, ptrdiff_t>(_Pbuf, _Count));
    }

template<class _Ty >

void return_temporary_buffer ( _Ty *  _Pbuf )

inline

    {   // delete raw temporary buffer
    operator delete(_Pbuf);
    }

template<class _InIt , class _FwdIt >

_FwdIt uninitialized_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest  )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...)
    return (_Rechecked(_Dest,
        _Uninitialized_copy0(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest))));
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...)
    if (_Count <= 0)
        return (_Dest);
    else
        return (_Rechecked(_Dest,
            _Uninitialized_copy_n(_Unchecked(_First), _Count,
                _Unchecked(_Dest))));
    }

template<class _FwdIt , class _Tval >

void uninitialized_fill ( _FwdIt  _First, _FwdIt  _Last, const _Tval &  _Val  )

inline

    {   // copy _Val throughout raw [_First, _Last)
    _Uninit_fill(_First, _Last, _Val, _Ptr_cat(_First, _First));
    }

template<class _FwdIt , class _Diff , class _Tval >

_FwdIt uninitialized_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval &  _Val  )

inline

    {   // copy _Count *_Val to raw _First
    return (_Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First)));
    }