class Foo { ... };
Foo* ptr = new Foo;	// 配置内存，然后构造对象
delete ptr;		    // 调用对象的析构函数将对象析构，然后释放内存

template <typename T>
class allocator {
public:
    // STL 要求的类型别名定义
    using value_type        = T;
    using pointer           = T*;
    using const_pointer     = const T*;
    using reference         = T&;
    using const_reference   = const T&;
    using size_type         = size_t;
    using difference_type   = ptrdiff_t;
public:
    // STL 要求的类接口，使用静态函数实现可以使频繁调用下减小开销
    // 负责分配内存
	static T*	allocate();
	static T*	allocate(size_type n);
	// 负责释放内存
	static void deallocate(T* ptr);
	static void deallocate(T*, size_type n);
	// 负责构造对象
	static void construct(T* ptr);
	static void construct(T* ptr, const T& value);
	static void construct(T* ptr, T&& value);
	// 负责析构对象
	static void destroy(T* ptr);
	static void destroy(T* first, T* last);
	// 获取某对象的地址
    static T*       address(T& val);
    // 获取可配置T类型对象的最大数目
    static size_t   max_size();
	// 使T类型的alloctor可以为U类型的对象分配内存
    template<typename U>
    struct rebind {
        using other = allocator<U>;
    }; 
};

// 使用::operator new实现，分配内存并返回空指针
// 使用static_cast将返回的void指针转换为目标类型的指针
template <typename T>
T* allocator<T>::allocate(size_type n) {
	return static_cast<T*>(::operator new(n * sizeof(T)));
}
// 使用::operator delete释放指针指向内存
template <typename T>
void allocator<T>::deallocate(T* ptr) {
	if (ptr != nullptr) ::operator delete(ptr);
}
// 负责构造对象，对全局函数construct()的调用
template <typename T>
void allocator<T>::construct(T* ptr) {
	mystl::construct(ptr);
}

template <typename T>
void allocator<T>::construct(T* ptr, const T& value) {
	mystl::construct(ptr, value);
}

template <typename T>
void allocator<T>::construct(T* ptr, T&& value) {
	mystl::construct(ptr, mystl::move(value));
}
// 负责析构对象，对全局函数destroy()的调用
template <typename T>
void allocator<T>::destroy(T* ptr) {
	mystl::destroy(ptr);
}

template <typename T>
void allocator<T>::destroy(T* first, T* last) {
	mystl::destroy(first, last);
}

// 使用了两个模板参数，并使用类型转换
template<typename T1, typename T2>
inline void construct(T1* ptr, const T2& value) { new(ptr) T1(value); } // placement new

// 单个参数的全局 destroy 函数，直接调用对象的析构函数
template<typename T>
inline void destroy(T* ptr) { ptr ->~T(); }

// destroy()内部调用的函数，根据对象类型是否有trivial destructor进行重载
// aux 为 auxiliary 缩写，表示其是辅助的函数
template<typename ForwardIterator>
inline void destroy_aux(ForwardIterator first, ForwardIterator last, _true_type) { }

template<typename ForwardIterator>
inline void destroy_aux(ForwardIterator first, ForwardIterator last, _false_type) {
    for(; first != last; ++first)
        destroy(first);
}

// 两个参数的全局 destroy 函数，根据其是否具有 trivial 析构函数进行重载
template<typename ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
	// value_type()函数可以取得迭代器指向对象的类型，注意此时还未实现
    using is_trivial_dtor =typename type_traits<value_type(first)>::has_trivial_destructor;
    destroy_aux(first, last, is_trivial_dtor());
}

template<typename ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
    // 由于暂未实现 mystl::iterator_traits，故而使用 std 中已有接口
    using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
    using is_trivial_dtor = typename type_traits<value_type>::has_trivial_destructor;
    destroy_aux(first, last, is_trivial_dtor());
}

#include <iostream>
#include <vector>
#include "allocator.h"
#include "type_traits.h"

int main(){
    std::vector<int,mystl::allocator<int>> vec(5,5);
    for(auto &each: vec)
        std::cout << each << " ";
    std::cout << std::endl;
    return 0;
}