Класс Вектор

#include <limits>
 
template<class AllocType>
class Allocator
{
public:
    typedef AllocType value_type;
    typedef AllocType* pointer;
    typedef AllocType& reference;
    typedef const AllocType* const_pointer;
    typedef const AllocType& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    Allocator();
    Allocator(const Allocator&);
    template<class OtherAlType>
    Allocator(const Allocator<OtherAlType>&) throw()
    {
    }
    Allocator& operator =(const Allocator&);
    ~Allocator();
    pointer adress (reference ref) const
    {
        return (&ref);
    }
    const_pointer adress (const_reference ref) const
    {
        return (&ref);
    }
    pointer allocate (size_type, const_pointer hint=0);
    void deallocate (pointer p, size_type n);
    const size_type max_size () const throw()
    {
        return std::numeric_limits<AllocType>::max();
    }
    pointer construct (pointer p, const_reference val);
    void destroy (pointer p);
    template<class OtherAlType>
    struct rebind
    {
        typedef Allocator<OtherAlType> other;
    };
};
 
template<class AllocType>
Allocator<AllocType>::Allocator() throw()
{
}
 
template<class AllocType>
Allocator<AllocType>::Allocator(const Allocator<AllocType>&)
{
}
 
template<class AllocType>
Allocator<AllocType>::~Allocator() throw()
{
}
 
template<class AllocType>
AllocType* Allocator<AllocType>::allocate(size_type sz, const_pointer hint=0)
{
    return new AllocType[sz];
}
 
template<class AllocType>
void Allocator<AllocType>::deallocate(pointer p, size_type)
{
    delete[] p;
}
 
template<class AllocType>
AllocType* Allocator<AllocType>::construct(pointer p, const_reference val)
{
    return new(p) AllocType(val);
}
 
template<class AllocType>
void Allocator<AllocType>::destroy(pointer p)
{
    p->~AllocType();
}
 
template<class AllocType>
Allocator<AllocType>& Allocator<AllocType>::operator =(const Allocator<AllocType> &)
{
    return *this;
}
 
template<class AllocType>
bool operator ==(const Allocator<AllocType>&, const Allocator<AllocType>&) throw()
{
    return true;
}
 
template<class AllocType>
bool operator !=(const Allocator<AllocType>&, const Allocator<AllocType>&) throw()
{
    return false;
}