mi::base::Std_allocator< T > Class Template Reference

An adaptor class template that implements a standard STL allocator. More...

Classes
struct	rebind
	Rebind helper struct to define a new class instance of this allocator template instantiated for the new value type T1. More...

Public Types
typedef T	value_type
	Value type allocated by this allocator. More...
typedef T *	pointer
	Pointer type. More...
typedef const T *	const_pointer
	Const pointer type. More...
typedef T &	reference
	Reference type. More...
typedef const T &	const_reference
	Const reference type. More...
typedef MISTD::size_t	size_type
	Size type. More...
typedef MISTD::ptrdiff_t	difference_type
	Difference type. More...

Public Member Functions
	Std_allocator () throw ()
	Default constructor. More...
	Std_allocator (base::IAllocator *allocator) throw ()
	Constructor. More...
template<class T1 >
	Std_allocator (const Std_allocator< T1 > &other) throw ()
	Copying constructor template for alike allocators of different value type. More...
pointer	address (reference x) const
	Returns address of object x allocated through this allocator. More...
const_pointer	address (const_reference x) const
	Returns const address of object x allocated through this allocator. More...
T *	allocate (size_type n, const void *=0) throw ()
	Allocate uninitialized dynamic memory for n elements of type T. More...
void	deallocate (pointer p, size_type)
	Frees uninitialized dynamic memory at location p that has previously been allocated with allocate(). More...
size_type	max_size () const throw ()
	Returns the maximum number of elements of type T that can be allocated using this allocator. More...
void	construct (pointer p, const_reference value)
	Calls the copy constructor of T on the location p with the argument value. More...
void	destroy (pointer p)
	Calls the destructor of T on the location p. More...
IAllocator *	get_allocator () const
	Returns the interface of the underlying allocator. More...
template<class T2 >
bool	operator== (Std_allocator< T2 > other) const throw ()
	Equality comparison. More...
template<class T2 >
bool	operator!= (Std_allocator< T2 > other) const throw ()
	Inequality comparison. More...

Detailed Description

template<class T>
class mi::base::Std_allocator< T >

An adaptor class template that implements a standard STL allocator.

The implementation of the STL allocator is based on the mi::base::IAllocator interface.

Template Parameters

T	The value type of the allocator.

Include File:

#include <mi/base/std_allocator.h>

Member Typedef Documentation

template<class T>

typedef const T* mi::base::Std_allocator< T >::const_pointer

Const pointer type.

template<class T>

typedef const T& mi::base::Std_allocator< T >::const_reference

Const reference type.

template<class T>

typedef MISTD::ptrdiff_t mi::base::Std_allocator< T >::difference_type

Difference type.

template<class T>

typedef T* mi::base::Std_allocator< T >::pointer

Pointer type.

template<class T>

typedef T& mi::base::Std_allocator< T >::reference

Reference type.

template<class T>

typedef MISTD::size_t mi::base::Std_allocator< T >::size_type

Size type.

template<class T>

typedef T mi::base::Std_allocator< T >::value_type

Value type allocated by this allocator.

Constructor & Destructor Documentation

template<class T>

mi::base::Std_allocator< T >::Std_allocator ( ) throw ( )

inline

Default constructor.

Uses mi::base::Default_allocator.

template<class T>

mi::base::Std_allocator< T >::Std_allocator ( base::IAllocator *  allocator) throw ( )

inline

Constructor.

Constructor from an mi::base::IAllocator interface.

Parameters

allocator

An implementation of the mi::base::IAllocator interface. Can be NULL in which case the mi::base::Default_allocator will be used.

template<class T>

template<class T1 >

mi::base::Std_allocator< T >::Std_allocator ( const Std_allocator< T1 > &  other) throw ( )

inline

Copying constructor template for alike allocators of different value type.

Member Function Documentation

template<class T>

pointer mi::base::Std_allocator< T >::address ( reference  x) const

inline

Returns address of object x allocated through this allocator.

template<class T>

const_pointer mi::base::Std_allocator< T >::address ( const_reference  x) const

inline

Returns const address of object x allocated through this allocator.

template<class T>

T* mi::base::Std_allocator< T >::allocate ( size_type  n, const void *  = 0  ) throw ( )

inline

Allocate uninitialized dynamic memory for n elements of type T.

Returns

The pointer to the allocated memory. Can be NULL if the underlying IAllocator implementation fails to allocate the memory.

template<class T>

void mi::base::Std_allocator< T >::construct ( pointer  p, const_reference  value  )

inline

Calls the copy constructor of T on the location p with the argument value.

template<class T>

void mi::base::Std_allocator< T >::deallocate ( pointer  p, size_type    )

inline

Frees uninitialized dynamic memory at location p that has previously been allocated with allocate().

Parameters

p	the memory to be freed. If p is equal to NULL, no operation is performed. However, note that according to

template<class T>

void mi::base::Std_allocator< T >::destroy ( pointer  p)

inline

Calls the destructor of T on the location p.

template<class T>

IAllocator* mi::base::Std_allocator< T >::get_allocator ( ) const

inline

Returns the interface of the underlying allocator.

template<class T>

size_type mi::base::Std_allocator< T >::max_size ( ) const throw ( )

inline

Returns the maximum number of elements of type T that can be allocated using this allocator.

template<class T>

template<class T2 >

bool mi::base::Std_allocator< T >::operator!= ( Std_allocator< T2 >  other) const throw ( )

inline

Inequality comparison.

Returns false if the underlying IAllocator interface implementations are the same.

template<class T>

template<class T2 >

bool mi::base::Std_allocator< T >::operator== ( Std_allocator< T2 >  other) const throw ( )

inline

Equality comparison.

Returns true if the underlying IAllocator interface implementations are the same, because then these allocators can be used interchangeably for allocation and deallocation.