STLdoc: stdext::allocators::allocator_base< _Ty, _Sync > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for stdext::allocators::allocator_base< _Ty, _Sync >:

Public Types
typedef size_t	size_type

typedef ptrdiff_t	difference_type

typedef _Ty *	pointer

typedef const _Ty *	const_pointer

typedef void *	void_pointer

typedef const void *	const_void_pointer

typedef _Ty &	reference

typedef const _Ty &	const_reference

typedef _Ty	value_type

Public Member Functions
	allocator_base ()

template<class _Other >
	allocator_base (const allocator_base< _Other, _Sync > &_Right)

pointer	address (reference _Val)

const_pointer	address (const_reference _Val)

template<class _Other >
pointer	allocate (size_type _Nx, const _Other *)

pointer	allocate (size_type _Nx)

void	deallocate (pointer _Ptr, size_type _Nx)

void	construct (pointer _Ptr, const _Ty &_Val)

template<class _Uty , class _Other >
void	construct (_Uty *_Ptr, const _Other &_Val)

template<class _Other >
void	construct (pointer _Ptr, _Other &&_Val)

template<class _Uty >
void	construct (_Uty *_Ptr)

template<class _Other >
void	destroy (_Other *_Ptr)

size_type	max_size () const

Member Typedef Documentation

template<class _Ty , class _Sync >

typedef const _Ty* stdext::allocators::allocator_base< _Ty, _Sync >::const_pointer

template<class _Ty , class _Sync >

typedef const _Ty& stdext::allocators::allocator_base< _Ty, _Sync >::const_reference

template<class _Ty , class _Sync >

typedef const void* stdext::allocators::allocator_base< _Ty, _Sync >::const_void_pointer

template<class _Ty , class _Sync >

typedef ptrdiff_t stdext::allocators::allocator_base< _Ty, _Sync >::difference_type

template<class _Ty , class _Sync >

typedef _Ty* stdext::allocators::allocator_base< _Ty, _Sync >::pointer

template<class _Ty , class _Sync >

typedef _Ty& stdext::allocators::allocator_base< _Ty, _Sync >::reference

template<class _Ty , class _Sync >

typedef size_t stdext::allocators::allocator_base< _Ty, _Sync >::size_type

template<class _Ty , class _Sync >

typedef _Ty stdext::allocators::allocator_base< _Ty, _Sync >::value_type

template<class _Ty , class _Sync >

typedef void* stdext::allocators::allocator_base< _Ty, _Sync >::void_pointer

Constructor & Destructor Documentation

template<class _Ty , class _Sync >

stdext::allocators::allocator_base< _Ty, _Sync >::allocator_base ( )

inline

694 { // default construct

695 }

template<class _Ty , class _Sync >

template<class _Other >

stdext::allocators::allocator_base< _Ty, _Sync >::allocator_base ( const allocator_base< _Other, _Sync > & _Right )

inline

         : _Sync(_Right)
         {   // construct by copying x
         }

Member Function Documentation

template<class _Ty , class _Sync >

pointer stdext::allocators::allocator_base< _Ty, _Sync >::address ( reference _Val )

inline

         {   // get address of _Val
         return (&_Val);
         }

template<class _Ty , class _Sync >

const_pointer stdext::allocators::allocator_base< _Ty, _Sync >::address ( const_reference _Val )

inline

         {   // get const address of _Val
         return (&_Val);
         }

template<class _Ty , class _Sync >

template<class _Other >

pointer stdext::allocators::allocator_base< _Ty, _Sync >::allocate	(	size_type	_Nx,
		const _Other *
	)

inline

         {   // allocate _Nx elements, ignore hint
         return (allocate(_Nx));
         }

template<class _Ty , class _Sync >

pointer stdext::allocators::allocator_base< _Ty, _Sync >::allocate ( size_type _Nx )

inline

         {   // allocate array of _Nx elements
         if (_Nx <= 0)
             _Nx = 0;
         else if (((size_t)(-1) / sizeof (_Ty) < _Nx))
             _STD _Xbad_alloc();
 
         if (_Nx == 1)
             return ((_Ty *)_Sync::allocate(sizeof (_Ty)));
         else
             return ((_Ty *)::operator new(_Nx * sizeof (_Ty)));
         }

template<class _Ty , class _Sync >

void stdext::allocators::allocator_base< _Ty, _Sync >::construct	(	pointer	_Ptr,
		const _Ty &	_Val
	)

inline

         {   // construct object at _Ptr with value _Val
         ::new ((void *)_Ptr) _Ty(_Val);
         }

template<class _Ty , class _Sync >

template<class _Uty , class _Other >

void stdext::allocators::allocator_base< _Ty, _Sync >::construct	(	_Uty *	_Ptr,
		const _Other &	_Val
	)

inline

         {   // construct object at _Ptr with value _Val
         ::new ((void *)_Ptr) _Uty(_Val);
         }

template<class _Ty , class _Sync >

template<class _Other >

void stdext::allocators::allocator_base< _Ty, _Sync >::construct	(	pointer	_Ptr,
		_Other &&	_Val
	)

inline

         {   // construct object at _Ptr with value _Val
         ::new ((void *)_Ptr) _Ty((_Other&&)_Val);
         }

template<class _Ty , class _Sync >

template<class _Uty >

void stdext::allocators::allocator_base< _Ty, _Sync >::construct ( _Uty * _Ptr )

inline

         {   // default construct
         ::new ((void *)_Ptr) _Uty();
         }

template<class _Ty , class _Sync >

void stdext::allocators::allocator_base< _Ty, _Sync >::deallocate	(	pointer	_Ptr,
		size_type	_Nx
	)

inline

         {   // deallocate array of _Nx elements
         if (_Ptr == 0)
             ;
         else if (_Nx == 1)
             _Sync::deallocate(_Ptr, sizeof (_Ty));
         else
             ::operator delete(_Ptr);
         }

template<class _Ty , class _Sync >

template<class _Other >

void stdext::allocators::allocator_base< _Ty, _Sync >::destroy ( _Other * _Ptr )

inline

         {   // destroy *_Ptr
         _Ptr->~_Other();
         }

template<class _Ty , class _Sync >

size_type stdext::allocators::allocator_base< _Ty, _Sync >::max_size ( ) const

inline

         {   // return maximum number of objects that could be allocated
         return ((size_t)(-1) / sizeof (_Ty));
         }

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

VS2013/inc/allocators