deallocate the storage. The rest is more or less obvious. As an example, let's look at a naive
implementation of the default allocator:
//util/defalloc.hpp
namespace std {
template <class T>
class allocator
{
public:
//type definitions
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
//rebind allocator to type U
template <class U>
struct rebind
{
typedef allocator<U> other;
};
//return address of values
pointer address (reference value) const
{
return (&value);
}
const_pointer address (const_reference value) const
{
return (&value);
}
/*constructors and destructor
*-nothing to do because the allocator has no state
*/
allocator() throw()
{
}
allocator(const allocator&) throw()
{
}
template <class U>
allocator (const allocator<U>&) throw()
{
}
~allocator() throw()
{
}
//return maximum number of elements that can be allocated
size_type max_size () const throw()
{
//for numeric_limits see Section 4.3, page 59
return (numeric_limits<size_t>::max() / sizeof(T));
}
//allocate but don't initialize num elements of type T
pointer allocate (size_type num,
allocator<void>::const_pointer hint = 0)
{
//allocate memory with global new
return(pointer) (:perator new(num*sizeof(T)));
}
//initialize elements of allocated storage p with value value
void construct (pointer p, const T& value)
{
//initialize memory with placement new
new((void*)p)T(value);
}
//destroy elements of initialized storage p
void destroy (pointer p)
{
// destroy objects by calling their destructor
p->~T();
}
//deallocate storage p of deleted elements
void deallocate (pointer p, size_type num)
{
//deallocate memory with global delete
:perator delete((void*)p));
}
};
//return that all specializations of this allocator are
interchangeable
template <class T1, class T2>
bool operator== (const allocator<T1>&,
const allocator<T2>&) throw()
{
return (true);
}
template <class T1, class T2>
bool operator!= (const allocator<T1>&,
const allocator<T2>&) throw()
{
return (false);
}
}