简单的自定义内存分配器

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <vector>
#include <iostream>


using namespace std;

namespace liuqi {
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(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 _destory(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 bind {
	typedef allocator<U> other;	
};


//hint used for locality. ref[Austern],p189
pointer allocate(size_type n, const void* hint=0) {
	return _allocate((difference_type)n, (pointer)0); 
}

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

void construct(pointer p, const T& value) {
	_construct(p, value);
}

void destory(pointer p) {
	_destory(p);
}

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

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

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


};

};



int main() {
	int ia[5] = {0, 1, 2, 3, 4};
	unsigned int i;
	vector<int, liuqi::allocator<int> > iv(ia, ia+5);
	for(i=0; i<iv.size(); i++) {
		cout << iv[i] << ' ';
	}
	cout << endl;
	return 0;
}