STL之自己实现简单地空间配置器allocater

阅读《STL源码分析》第二章 仿照书上2.1.1节编写了一个自己的简易空间配置器

1 储备知识

size_t是unsigned类型，用于指明数组长度或下标，它必须是一个正数，std::size_t

ptrdiff_t是signed类型，用于存放同一数组中两个指针之间的差距，它可以使负数，std::ptrdiff_t.

size_type是unsigned类型,表示容器中元素长度或者下标，vector::size_type i = 0;

difference_type是signed类型,表示迭代器差距，vector:: 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

当参数p为0时，即抛出异常

Q:set_new_handler(0)什么意思？
A:见知乎高赞回答：set_new_handler(0)什么意思？
但我的代码里放置这句话会报错，还是没懂

代码 环境VS2015

#ifndef _ZYTALLOC_
#define _ZYTALLOC_

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


namespace ZYT
{
	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)
		{
			std::cout << "out of memeory" <<std:: 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 allocater {
	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 allocater<U>other;
		};
		pointer allocate(size_type n, const void*hint = 0)
		{
			return _allocate<T>((difference_type)n, (pointer)0);
		}
		void deallocate(pointer p, size_type n) { _deallocate(p); }
		void construst(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)); }



	};
}


#endif _ZYTALLOC_

int main()
{
	using namespace ZYT;
	ZYT::allocater<int>a;
	int *ptr = a.allocate(2);
	a.construst(ptr, 10);
	a.construst(ptr + 1, 20);
	std::cout << *ptr << std::endl;
	std::cout << ptr[1] << std::endl;
	a.destroy(ptr);
	a.destroy(ptr + 1);
	a.deallocate(ptr,2);
	std::cout << *ptr << std::endl;
	allocater<int>::rebind<double> ::other dalloc;
	double *p = dalloc.allocate(2);
	dalloc.construst(p, 3.5);
	std::cout << *p << std::endl;
	dalloc.destroy(p);
	dalloc.deallocate(p, 2);
	std::cout << *p << std::endl;
    return 0;
}