根据allocator的标准接口，编写的功能、接口不齐全的allocator

#ifndef MYALLOC_H
#define MYALLOC_H

#include<new>//for placement new
#include<cstddef>//for ptrdiff_t size_t
#include<cstdlib>//for exit
#include<climits>//for unit_Max
#include<iostream>

namespace JJ{
	template<class T>
	inline T* _allocate(ptrdiff_t size,T *)
	{
		set_new_handler(0);
		T* tmp = (T*)operator new((size_t)(size*sizeof(T)));
		if(NULL == tmp){
			cout<<"out of memory"<<endl;
			exit(1);
		}
		return tmp;
	}

	template<class T>
	inline void _deallocate(T* buf)
	{
		::operator delete(buf);
	}

	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;

		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 ptr,size_type n)
		{
			_deallocate(ptr);
		}

		void construct(pointer ptr,const T& t)
		{
			_construct(ptr,t);	
		};

		void distroy(pointer ptr)
		{
			_destroy(ptr);
		}

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

		const_pointer const_address(reference x)const
		{
			return (const_pointer)&x;
		}

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

};

#endif