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

这个简单实现类中的方法主要是有

allocate()

deallocate()

construct()

destroy()

实际在SGI STL中construct()和destroy()是以全局函数的方式出现的~~//jjalloc.h
#ifndef JJALLOC_H
#define JJALLOC_H

#include <new> //for placement new
#include <cstddef> //for ptrdiff_t, size_t
#include <cstdlib> //for exit(1)
#include <iostream> //for cerr
#include <climits> //for UINT_MAX

namespace JJ {

template <typename T>
inline T* _allocator(ptrdiff_t size, T*) {
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 <typename T>
inline void _deallocate(T *buffer) {
::operator delete(buffer);
}

template <typename T1, typename T2>
inline void _construct(T1 *p, const T2 &value) {
new(p) T1(value); //定位new表达式
}

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

template <typename 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 <typename U>
struct rebind {
typedef allocator<U> other;
};

//hint used for locality
pointer allocate(size_t 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, 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

#endif