自己动手写的allocate,还有待完善

/*
*Version:1
*Date: 10/23
*CopyRight:pjGan
*/
#ifndef DEFINE_DATA
#define DEFINE_DATA
#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>

namespace MyAllocateSpace{
    template <typename T>
    inline T* _allocate(std::ptrdiff_t size, T*){
        std::set_new_handler(0);
        T *pTmp = (T *)(::operator new(static_cast<std::size_t>(size*sizeof(T))) );
        if(NULL == pTmp) {
            std::cerr<<"Memory failed"<<std::endl;
            exit(1);
        }
        return pTmp; 
    }

    template <typename T>
    inline void _deallocate(T *pBuff) {
        if(NULL == pBuff) {
            std::cerr<<"Delete the Memory failed"<<std::endl;
            exit(1);
        } 
        ::operator delete(pBuff);
    }

    template <typename Type1, typename Type2>
    inline void _construct(Type1 *pType, const Type2 &r_Value) {
        new(pType) Type1(r_Value);
    }

    template <typename T>
    inline void _destory(T *ptr) {
        ptr->~T();
    }

    template <typename T>
    class Myallocator_ {
    public:
        typedef T                          value_type;
        typedef T*                         pointer;
        typedef const T*                 const_pointer;
        typedef T&                        reference;
        typedef std::size_t             size_type;            
        typedef const T&                const_reference;
        typedef std::ptrdiff_t          difference_type;

        template <typename U>
        struct rebind {
            typedef Myallocator_<U> other;
        };

        pointer allocate(size_type n, const void * hint = 0) {
            return _allocate(static_cast<difference_type>(n), static_cast<pointer>(0));
        }

        void deallocate(pointer p, size_type n) {
            _deallocate(p);
        }

        void destory(pointer p, const T &r_value) {
            _construct(p, r_value);
        }

        pointer address(reference x) {
            return static_cast<pointer>(&x);
        }

        const_pointer const_address(const_reference x) {
            return static_cast<const_pointer>(&x);
        }

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

    };
} //end of MyAllocateSpace
#endif //DEFINE_DATA

#include <iostream>
#include "DefineData.h"

#include <vector>
int main(){
    int iArrayData[5] = {0, 1, 2, 3, 4};
    std::vector<int, MyAllocateSpace::Myallocator_<int> >iv(iArrayData, iArrayData+5); //自己构造的allocate
    return 0;
}