设计一个简单的空间配置器 JJ::allocator

#ifndef _JJALLOC_
#define _JJALLOC_
#include<new>//for placement new
#include<cstdlib>//for ptrdiff_t,size_t
#include<climits>//for UINT_MAX
#include<iostream>//for cerr

namespace JJ
{

template<class T>
inline T* _allocate(ptrdiff_t size,T*){
//当operator new申请一个内存失败的时候.
//如果存在客户指定的处理函数，则调用处理函数（new_handler），如果不存在则抛出一个异常
//参数为0，则抛出异常
set_new_handler(0);
T* tmp=(T*)(::operator new((size_t)(size*sizeof(T))));
if(tmp==0){
cerr<<"out of memory"<<endl;
exit(1);
}
return tmp;
}

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 allocator 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););
};
};

} //end of namespace JJ
#endif _JJALLOC_

1.类型介绍：

size_t是unsigned类型，用于指明数组长度或下标，它必须是一个正数，std::size_t
ptrdiff_t是signed类型，用于存放同一数组中两个指针之间的差距，它可以使负数，std::ptrdiff_t.
size_type是unsigned类型,表示容器中元素长度或者下标，vector<int>::size_type i = 0;
difference_type是signed类型,表示迭代器差距，vector<int>:: difference_type = iter1-iter2.

2.

<span style="font-family:Microsoft YaHei;">set_new_handler(0)介绍</span>

当operator new申请一个内存失败的时候，它会进行如下的处理步骤：

1、如果存在客户指定的处理函数，则调用处理函数（new_handler），如果不存在则抛出一个异常。

2、继续申请内存分配请求。

3、判断申请内存是否成功，如果成功则返回内存指针，如果失败转向处理步骤1

为了自定义这个“用以处理内存不足”的函数new_handler，用户可以调用set_new_handler进行设置

这两个函数声明如下：

namespace std{

typedef void (*new_handler)();

new_handler set_new_handler(new_handler p) throw();

}

其中，new_handler是个typedef，定义一个函数指针，该函数没有参数，也没有返回值；

set_new_handler用于设置处理函数，设置p为当前处理函数，并返回之前的new_handler
当参数p为0时，即抛出异常