tinystl实现（第四步：allocator.h）

经过长时间的学习终于可以开始tinystl的仿（chao）写工作了，本文参考了这位大佬的github，坦白讲我只是补充了注释，因为tinystl的代码真的非常经典而我又没什么这种大型项目的经验，所以只能这样做，不过相信能够有助于大家的学习
#强烈建议按顺序阅读本专栏
allocator.h是alloc.h和construct.h的直接上级，在这个文件中我们看到了很多我们似曾相识的语句，回忆它们与之前的不同，我们不难发现这一文件的意义：封装和保护（语句中增加了强制转型，对于不同类的适用性增强，而pod等底层部分的处理却在这里不在出现）

#pragma once
#ifndef  _ALLOCATOR_H_
#define _ALLOCATOR_H_

#include"Alloc.h"
#include"Construct.h"

#include<cassert>
#include<new>

namespace mySTL {
	//空间适配器，以变量数目为单位分配
	template<class T >
	class allocator {
	public:
		typedef T value_type;
		typedef T* pointer;
		typedef T& reference;
		typedef const T& const_reference;
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;//ptrdiff_t类型变量通常用来保存两个指针减法操作的结果。
	public:
		static T *allocate();
		static T *allocate(size_t n);
		static void deallocate(T *ptr);
		static void deallacate(T *ptr, size_t n);

		static void construct(T *ptr);
		static void construct(T *ptr, const T& value);
		static void destroy(T *ptr);
		static void destroy(T *first, T *last);
	};
	template<class T>
	 T *allocator<T>:: allocate(){
		 return static_cast<T *>(alloc::allocate(sizeof(T)));//alloc里的allocate和这个allocate不一样！
	}//static_cast是一个c++运算符，功能是把一个表达式转换为某种类型，但没有运行时类型检查来保证转换的安全性。
	 template<class T>
	 T *allocator<T> ::allocate(size_t n) {
		 if (n == 0)return;
		 return static_cast<T *>(alloc::allocate(sizeof(T)*n));//一次性申请多个T大小的空间
	 }
	template<class T>
	void allocator<T> ::deallocate(T *ptr) {
		alloc::deallocate(static_cast<void *>(ptr), sizeof(T));//注意强制转型，调用alloc中的deallocate
	}
	template<class T>
	void allocator<T> ::deallacate(T *ptr, size_t n) {
		if (n == 0)return;
		alloc::deallocate(static_cast<void *>(ptr), sizeof(T)*n);//批量处理deallocate
	}

	template<class T>
	void allocator<T> ::construct(T *ptr) {
		new(ptr)T();//用new为地址ptr调用构造函数
	 }
	template<class T>
	void allocator<T> ::construct(T *ptr, const T& value) {
		new(ptr)T(value);//用new为地址ptr调用构造函数
	 }
	 template<class T>
	 void allocator<T> ::destroy(T *ptr) {
		 ptr->T();//调用析构函数
	 }
	 template<class T>
	 void allocator<T> ::destroy(T *first, T *last) {
		 for (; first != last; ++first) {
			 first->~T();//逐一调用析构函数
		 }
	 }
}
#endif // ! _ALLOCATOR_H_