C++适配器 priority_queue && queue && stack 模拟实现(初阶)

#pragma once
#include<vector>
using std::vector;
using std::swap;
namespace sxh_priority_queue
{
	template<typename T>
	struct less
	{
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};
	template<typename T>
	struct greater
	{
		bool operator()(const T& a, const T& b)
		{
			return a > b;
		}
	};
	template<typename T,typename container = vector<T>, typename compare = greater<T>>
	class priority_queue
	{
	public:
		void Adjustup(int child)
		{
			int father = (child - 1) / 2;
			while (child > 0)
			{
				if (compare()(child, father))
				{
					std::swap(_con[father], _con[child]);
					child = father;
					father = (child - 1) / 2;
				}
				else
				{
					break;
				}
			};

		}
		void push(const T& x)
		{
			_con.push_back(x);
			int child = _con.size() - 1;
			Adjustup(child);
		}
		void Adjustdown(int root)
		{
			int child = (root * 2) + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && compare()(_con[child + 1], _con[child]))
				{
					child++;
				}
				if (compare()(child, root))
				{
					std::swap(_con[child], _con[root]);
					root = child;
					child = (root * 2) + 1;
				}
				else
				{
					break;
				}
			}
		}
		void pop()
		{
			int child = _con.size() - 1;
			std::swap(_con[0], child);
			_con.pop_back();
			Adjustdown(0);
		}
		const T& top()
		{
			return _con.front();
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}

	private:
		container _con;
	};
}

///////////////////////////////////////////////////////

#pragma once
#include"my_vector.h"
#include<deque>
using namespace sxh_vector;
namespace sxh_stack
{
	template<typename T,typename Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			sta.push_back(x);
		}
		void pop()
		{
			sta.pop_back();
		}
		const T& top()const
		{
			return sta.back();
		}
		T& top()
		{
			return sta.back();
		}
		bool empty()
		{
			sta.empty();
		}
		size_t size()
		{
			return sta.size();
		}
	private:
		Container sta;
	};
}

//////////////////////////////////////////

#pragma once
#include<deque>
using std::deque;
namespace sxh_stack
{
	template<typename T, typename Container = deque<T>>
	class queue
	{
	public:

		void push(const T& x)
		{
			que.push_back(x);
		}
		void pop()
		{
			que.pop_front();
		}
		const T& front()const
		{
			return que.front();
		}
		T& front()
		{
			return que.front();
		}
		const T& back()const
		{
			return que.back();
		}
		T& back()
		{
			return que.back();
		}
		bool empty()
		{
			que.empty();
		}
		size_t size()
		{
			return que.size();
		}
	private:
		Container que;
	};
}