【C++】STL使用仿函数控制优先级队列priority_queue

#pragma once
//优先级队列底层是堆，heap
namespace bit
{
  //仿函数
  template<class T>
  class Less
  {
  public:
    bool operator()(const T& t1, const T& t2)
    {
      return t1 < t2;
    }
  };
  template<class T>
  class Greater
  {
  public:
    bool operator()(const T& t1, const T& t2)
    {
      return t1 > t2;
    }
  };
  //类名不是类型
  template<class T, class Container = vector<T>, class Compare = Less<T> >
  //默认大堆
  class PriorityQueue
  {
    //com是一个仿函数
    Compare com;
    void AdjustDown(int parent)
    {
      int child = parent * 2 + 1;
      while (child > 0)
      {
        //可能右孩子存在且大于左孩子
        if (child + 1 < _con.size() && com(_con[child],_con[child + 1]))
        {
          ++child;
        }
        //如果孩子存在且孩子大于父亲，交换
        if (child < _con.size() && com(_con[parent],_con[child]))
        {
          swap(_con[child], _con[parent]);
          parent = child;
          child = parent * 2 + 1;
        }
        else
        {
          break;
        }
      }
    }
    void AdjustUp(int child)
    {
      Compare com;
      //类名实例化类对象，该类型是一个仿函数，实例化的com可以调用仿函数的比较方法
      //记录父亲的下标
      int parent = (child - 1) / 2;
      while (child > 0)
      { 
        if (com(_con[parent], _con[child]))
        {
          swap(_con[child], _con[parent]);
        }
        child = parent;
        parent = (child - 1) / 2;
      }
    }
  public:
    PriorityQueue()
    {}
    //默认建大堆
    template<class InputIterator>
    PriorityQueue(InputIterator first, InputIterator end)
    {
      //插入数据
      while (first != end)
      {
        _con.push_back(*first);
        ++first;
      }
      //向下调整建堆
      for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
      {
        AdjustDown(i);
      }
    }
    void push(const T& val)
    {
      //插入元素
      _con.push_back(val);
      //然后向上调整
      AdjustUp(_con.size() - 1);
    }
    void pop()
    {
      //1.堆顶和堆尾交换
      swap(_con[0], _con[_con.size() - 1]);
      //2.删除堆尾
      _con.pop_back();
      //3.向下调整，恢复堆
      AdjustDown(0);
    }
    T& top() 
    {
       return _con[0];
    }
    size_t size() const
    {
      return _con.size();
    }
    bool empty() const
    {
      return _con.empty();
    }
  private:
    Container _con;

//仿函数
template<class T>
class Less
{
public:
  bool operator()(const T& t1, const T& t2)
  {
    return t1 < t2;
  }
};
template<class T>
class Greater
{
public:
  bool operator()(const T& t1, const T& t2)
  {
    return t1 > t2;
  }
};