template <class T>
class allocator
{
    typedef void* (__cdecl* malloc_t)(size_t);
    typedef void (__cdecl* free_t)(void*);
public:
    typedef T            value_type;
    typedef T*            pointer;
    typedef const T*    const_pointer;
    typedef T&            reference;
    typedef const T&    const_reference;
    typedef size_t        size_type;
    typedef ptrdiff_t    difference_type;

public:
    allocator() : 
        m_pfMalloc(&malloc), m_pfFree(&free) 
            {}
    allocator(const allocator<T>& _all) : 
        m_pfMalloc(_all.m_pfMalloc), m_pfFree(_all.m_pfFree) 
            {}
    template <class R>
    allocator(const allocator<R>& _all) : 
        m_pfMalloc(_all.m_pfMalloc), m_pfFree(_all.m_pfFree) 
            {}

    pointer adddress(reference _val) const
        { return &_val; }
    const_pointer address(const_reference _val) const
        { return &_val; }

    pointer allocate(size_type _size)
        { return (pointer)m_pfMalloc(_size); }
    template <class R>
    pointer allocate(size_type _size, const R*)
        { return (pointer)m_pfMalloc(_size); }

    void construct(pointer _ptr, const T& _val)
        { new((void*)_ptr) T(_val); }

    void deallocate(pointer _ptr, size_type)
        { m_pfFree(_ptr); }

    void destroy(pointer _ptr)
        { _ptr->~T(); }

    size_type max_size() const
        { return (size_type)(-1) / sizeof (T); }

    template<class R>
    struct rebind 
    {
        typedef allocator<R> other;
    };
    
public:
    malloc_t    m_pfMalloc;
    free_t        m_pfFree;
};