#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  
#include<vector>

using namespace std;


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_  


int main()
{
	int ia[] = { 1, 2, 3, 4, 5 };
	std::vector<int, JJ::allocator<int>>iv(ia, ia + 5);

	for (int i = 0; i < iv.size(); i++)
		cout << iv[i] << " ";
	cout << endl;
	return 0;
}
 

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.

當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