#ifndef  JJALLOC_H
#define JJALLOC_H
#include<new>
#include <cstddef>
#include<cstdlib>
#include<climits>
#include <iostream>
namespace JJ
{
template<class T>
inline T* _allocate(ptrdiff_t size,T*){
    /*set_new_handler则是一个输入并返回
    new_handler类型的函数。set_new_handler的
    输入参数是operator new分配内存失败时要调
    用的出错处理函数的指针，返回值
    是set_new_handler没调用之前就
    已经在起作用的旧的出错处理函数的指针*/
    set_new_handler(0);
    T* tem=(T*)(::operator new((size_t)(size *sizeof(T))));
    if(tem==0){
        cout<<"out of memory"<<endl;
        exit(1);
    }
    return tem;
}
template<class T>
inline void _deallocate(T* buffer){
    ::operator delete(buffer);
} 
template<class T1,class T2>
inline void _construct(T1* p,const T2& value){
   new(p) T1(value);
}
template<class T>
inline void _destroy(T* ptr){
    ptr->~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;
    //rebind alloctor of type u
    template<class U>
        struct rebind{
        typedef allocator<U> other;
    };
    pointer allocate(size_type n,const void* hint=0){
        return _allocate((difference_type)n,(pointer)0);
    }
    void deallocate(pointer p,size_type n){
        _deallocate(p);
    }
    void construct(pointer p,const T& value){
        _construct(p,value);
    }
    void destroy(pointer p){
        _destroy(p);
    }
    pointer address(reference x){
        return (pointer)&x;
    }
    const_pointer const_address(const_reference x){
        return (const_pointer)&x;
    }
    size_type max_size() const{
        return size_type(UINT_MAX/sizeof(T));
    }

};
}
#endif //JJALLOC_H

#include "jjalloc.h"
#include<iostream>
using namespace std;
class Test
{
  public:
      int x;
      Test(int b=0){
          x=b;
          
      }
      ~Test(){

      }
};
int main()
{
    int x=4;
    JJ::allocator<int> a;
    JJ::allocator<Test> b;
    int *p=a.allocate(1);
    Test *t=new Test;
    //new(p) T1(value) 这叫place new,在指针p所指向的内存空间创建一个
    //类型为T1的对象。调用的构造函数接受一个类型为const 
//    T2&（或其他兼容类型）的参数
//    new(&t) Test(x);
    b.construct(t,x);
    *p=1;
    cout<<*p<<endl;
    cout<<t->x<<endl;
    cout <<*(a.address(x))<<endl;
    cout <<a.max_size()<<endl;
    b.destroy(t);
    a.deallocate(p,1);
    return 0;
}