STL源码剖析01-allocator

#include <iostream>
#include <new>
#include <cstddef>
#include <vector>
using namespace std;
template <class T>
inline T* _allocator(ptrdiff_t size, T*)
{
	std::cout<<"_allocator()"<<std::endl;
	set_new_handler(0);
	T* tmp = (T*)(::operator new((size_t)size * sizeof(T)));
	if (tmp == NULL)
	{
		exit(1);
	}
	return tmp;
}

template<class T>
inline void _deallocator(T * buffer)
{
	std::cout<<"_deallocator()"<<std::endl;
	::operator delete(buffer);
}

template<class T1, class T2>
inline void _constructor(T1* p, const T2& value)
{
	std::cout<<"_constructor()"<<std::endl;
	new(p) T1(value);
}

template <class T>
inline void _destroy(T* ptr)
{
	std::cout<<"_destroy()"<<std::endl;
	ptr->~T();
}


template<class T>
class jjAllocator
{
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 jjAllocator<U> other;
	};

	jjAllocator() {}  
	jjAllocator(const jjAllocator&) {}  

	template <class U>  
	jjAllocator(const jjAllocator<U>&) {}  

	~jjAllocator() {}  

	pointer allocate(size_type n, const void* hint = 0)
	{
		return _allocator((ptrdiff_t)n, (pointer)0);
	}

	void deallocate(pointer p, size_type n)
	{
		_deallocator(p);
	}

	void construct(pointer p, const T& value)
	{
		_constructor(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));
	}
};

int main()
{
	std::vector<int, jjAllocator<int>>mmm;
	mmm.push_back(1);
	mmm.push_back(2);
	system("pause");
	return 1;
}