template <typename T>
constexpr typename remove_reference<T>::__type&& move(T &&val) noexcept{
	return static_cast<typename remove_reference<T>::__type &&>(val);
}

// 定义结构体模板
template <typename T>
struct remove_reference {
	typedef T __type;
};

// 左值显式特化版本
template <typename T>
struct remove_reference<T&> {
	typedef T __type;
};

// 右值显式特化版本
template <typename T>
struct remove_reference<T&&> {
	typedef T __type;
};

// 完美转发 : 左值转发
template <typename T>
constexpr T&& forward(typename remove_reference<T>::__type& val) noexcept{
	return static_cast<T&&>(val);
}

/*
  有两个是为了类型一一对应 这里使用了 remove_reference 所以一个固定接受左值引用
	一个固定接受右值，当结果是左值的时候，与T&& 折叠，结果仍然是左值
	当结果是右值时，与T&&折叠结果仍然是右值，达到完美转发的效果
	他并不是所有值进来都转换成右值，这和move是不一样的，也不能和move一样！所以需要区别使用
	而不是直接一个函数无脑 返回 T&&
*/

// 完美转发 ： 右值转发
template <typename T>
constexpr T&& forward(typename remove_reference<T>::__type&& val) noexcept
{
	// 静态断言 如果传入的是个左值就报错
	static_assert(!is_lvalue_reference<T>().value, "ni bu neng yong forward jiang yi ge zuo zhi zhuan huan cheng you zhi");
	return static_cast<T&&>(val);
}

template <typename T>
class allocator
{
public:
	typedef T value_type; // 基础数据类型
	typedef T* pointer; // 基础数据指针
  
public:
	allocator() = default;
	~allocator() = default;

// 分配size个空间，size_type 就是unsigned 类型
	static pointer allocate(size_type size) noexcept
	{
		if (size == 0) {
			return nullptr;
    }
		return static_cast<pointer>(::operator new(size * sizeof(value_type)));
	}

static void deallocate(pointer ptr, size_type size) noexcept
{
		if (ptr == nullptr) {
			return;
		}
		::operator delete(ptr);
}

  template <typename... Args>
	static void construct(pointer ptr, Args&&... args) noexcept
	{
		// 构造类的时候可能有多个参数，这些参数可能是左值，可能是右值，所以我们需要完美转发
		// 完美转发需要配合万能引用使用，所以Args 必须是 &&
		::new(ptr) value_type(yuriSTL::forward<Args>(args)...);
	}

// 简单指针，直接调用析构函数就行
template <typename T>
void destroy(T* ptr) {
	ptr->~T();
}简单指针直接调用析构就行

// 是简单类型什么都不用做
template <typename T>
void destroy__(T* start, T* end, __true_type) { }

// 不是简单类型调用析构函数
template <typename T>
void destroy__(T* start, T* end, __false_type)
{
	// 循环调用析构函数
	for (; start != end; start++) {
		start->~T();
	}
}

// 析构n个数据
template <typename T>
void destroy(T* start, T* end)
{
	// 判断是不是基础类型
	typename is_type<T>::__type type;
	// 通过另一个函数完成最终析构
	destroy__(start, end, type);
}

template <typename T>
class vector final
{
public:
	typedef T value_type; // 数据类型
	typedef T* iterator; // 指针/迭代器
  typedef T& reference; // 引用

// 成员变量
private:
	value_type* begin_; // 指向一块内存的起始地址
	value_type* end_; // 最后一个元素的下一个位置
	value_type* tail_; // 内存块的最后一块地址
	allocator<T> alloc; // 新建分配内存的工具

	vector() noexcept
	{
    // 申请空间
		begin_ = alloc.allocate(16); 
    // 异常返回
		if (begin_ == nullptr) {
			yuriSTL::log("内存分配失败捏!"); // 以红色字体终端打印消息
			exit(1); // 并且退出程序，错误代码1
		}
		// 更新指针位置
		end_ = begin_; 
		tail_ = begin_ + 16;
	}

vector(vector<value_type> &v) noexcept
	{
		// 新建一块和他一样大的内存
    begin_ = alloc.allocate(v.max_size());
  	// 异常判断
		if (begin_ == nullptr) {
			yuriSTL::log("内存分配失败捏!");
			exit(1);
		}
		// 更新指针
		const int size = v.size();
		end_ = begin_ + size;
		tail_ = begin_ + v.max_size();
		// 调用构造函数进行构造
		for (int i = 0; i < size; i++) {
			alloc.construct(begin_ + i, *(v.begin() + i));
		}
	}

// 移动构造函数
	vector(vector<value_type> &&v) noexcept
	{
		// 移动资源
		begin_ = v.begin_;
		end_ = v.end_;
		tail_ = v.tail_;

		// 将原来的地址设置为nullptr
		v.begin_ = nullptr;
		v.end_ = nullptr;
		v.tail_ = nullptr;
	}

// 使用n个对象初始化
	explicit vector(const size_type n)
	{
		// 申请空间
		begin_ = alloc.allocate(n);
		// 异常返回
		if (begin_ == nullptr) {
			yuriSTL::log("内存分配失败捏!");
			exit(1);
		}
		// 更新指针
		end_ = begin_;
		tail_ = begin_ + n;
	}

// 初始化n个元素
	vector(const size_type n, const value_type &val)
	{
		// 申请空间
		begin_ = alloc.allocate(n);
		// 异常返回
		if (begin_ == nullptr) {
			yuriSTL::log("内存分配失败捏!");
			exit(1);
		}
		// 更新指针
		end_ = begin_ + n;
		tail_ = begin_ + n;
		// 初始化元素
		for (int i = 0; i < n; i++) {
			alloc.construct(begin_ + i, val);
		}
	}

// 析构函数
	~vector() 
	{
		// 调用函数对类进行析构
		alloc.destroy(begin_, end_);
		// 删除掉申请的内存
		if (begin_) {
			alloc.deallocate(begin_);
		}
		// 将他们设置为nullptr 防止被重新利用
		begin_ = nullptr;
		end_ = nullptr;hu shi hua
		tail_ = nullptr;
	}

// 从尾部插入元素 左值
	void push_back(const value_type& val)
	{
		// 判断空间是不是满了
		if (end_ == tail_) {
			relloc(); // 如果空间满了则重新分配空间默认 大小 X 2
		}
		// 插入，并更新指针
		alloc.construct(end_++, val);
	}

// 从尾部插入元素 右值
	void push_back(value_type&& val)
	{
		// 判断空间是不是满了
		if (end_ == tail_) {
			relloc();
		}
		// 通过完美转发传递参数
		alloc.construct(end_++, yuriSTL::forward<value_type>(val));
	}

// 返回当前元素个数
    const int size() {
        return end_ - begin_;
    }

// 返回最大元素个数
    const int max_size() {
        return tail_ - begin_;
    }

// 判断容器是否为空
	const bool empty() { 
	  return end_ == begin_; 
	}

// 返回首部元素
	reference front() 
	{
		if (empty()) {
			yuriSTL::log("当前元素为空!");
			exit(3);
		}
		return *begin_;
	}

// 返回末尾元素
	reference back()
	{
		if (empty()) {
			yuriSTL::log("当前元素为空!");
			exit(3);
		}
		return *(end_ - 1);
	}

iterator begin() noexcept { 
  return begin_; 
}

// 返回末尾迭代器
	iterator end() noexcept { 
	  return end_;
  }

iterator data() noexcept { 
  return begin_; 
}

// 返回对应元素个数
	reference at(const int k)
	{
		if (k >= end_ - begin_) {
			yuriSTL::log("错误！超出内存范围!");
			exit(2);
		}
    return *(begin_ + k);
	}

// 重载[] 返回对应下标元素
	reference operator[](int k)
	{
      if (k >= end_ - begin_) {
			  yuriSTL::log("错误！超出内存范围!");
			  exit(2);
      }
      return *(begin_ + k);
	}

// 重载等号
	reference operator=(cosnt vector<value_type> &v)
	{
		// 调用函数对之前的数据进行析构
		alloc.destroy(begin_, end_);
		// 删除掉之前申请的内存
		alloc.deallocate(begin_);
		// 重新申请内存
		begin_ = alloc.allocate(v.max_size());
		// 判断是否异常
    if (begin_ == nullptr) {
			yuriSTL::log("内存分配失败捏!");
			exit(1);
		}
		// 更新指针
		end_ = begin_ + v.size();
		tail_ = begin_ + v.max_size();
		// 完成初始化操作
		for (int i = 0; i < v.size(); i++) {
			*(begin_ + i) = *(v.begin_ + i);
		}

		return *this;
	}