STL之简单空间适配器实现

/* 简单的空间适配器实现
    主要代码来源为 《STL源码剖析》
*/ 

#include<new>
#include<cstddef> //ptrdiff_t 保存两指针相减为long int ,size_t 记录大小的数据类型 
#include<cstdlib> // exit()
#include<climits>//UINT_MAX
#include<iostream>// cerr 输出标准错误ostream对象



namespace mosquito
{
    template <class T>
    inline T* _allocate(ptrdiff_t size ,T*)//开辟空间 
    {
        T * tmp = (T*)(::operator new ((size_t)(size * sizeof(T))));//创建一个size* sizeof(T) 大小的空间并转换为size_t类型并且把它的指针转换为T*并返回 
        if(tmp == 0)
        {
        //  cerr << " no memory " << endl;
            exit(1);
        }
        return tmp;
    } 

    template<class T>//销毁空间 
    inline void _dellocate(T* tmp)
    {
        ::operator delete(tmp);
    }

    template <class T1 , class T2>
    inline void _construct (T1* p ,const T2 & value)//构造 
    {
        new(p) T1(value);//给P指针 构造一个新的T1实例  为了P-> ~T1(); 
    }

    template <class T>
    inline void _destroy(T* ptr)//析构 
    {
        ptr->~T();//显式的调用T的析构函数 
     }

    template <class T>
    class allocator{
        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;


            template <class M>
            struct rebind{
                typedef allocator<M> other;
            };

        pointer allocate(size_type n ,const void* hint = 0 )    //调用了_allocate来申请空间并返回指针 
        {
            return _allocate( (difference_type)n , (pointer)0 );
        }

        void dellocate ( pointer p , size_type n )//调用_dellocate 
        {
            _dellocate(p); 
        }

        void construct( pointer p , const T& value )
        {
            _construct(p , value);
        }

        void destroy (pointer p)
        {
            _destroy(p);
        }

        pointer adderss(reference x)
        {
            return (pointer)&x;
        }

        const_pointer const_address( const_reference x )
        {
            return (const_pointer)&x;
        }

        size_type max_size() const //const限制此函数修改类成员 
        {
            return size_type (sizeof(T));
        }
    }; 
 } 

此为空间适配器的简单实现，主要运用标准库new。
整个实现主要在于 _allocate(),_dellocate(),_construct(),_destory()这四个函数，类allocator是对这四个主要函数进行了封装。
新的知识：1.ptrdiff_t
2.size_t
3.placement new (new(p) T(value));