【C++】详解priority_queue（优先级队列）与函数对象

一、priority_queue 的介绍和使用

1.1priority_queue 的介绍

2.2priority_queue 的使用

二、仿函数

2.1什么是仿函数

2.2仿函数的作用

三、函数对象的特点（知识点多）

3.1分析特点5（比较普通函数与函数对象）

3.1.1利用普通函数传递参数

拓展之：深度剖析函数利用模板的本质

3.1.2利用函数对象传递参数

3.1.3函数对象作为for_each的参数（知识点较多）

2.第三个参数传递函数：（计算从0到100）

3.第三个参数传递函数对象：（计算从0到100）

4.难点：关于第三个参数是传值的易错点

5.拓展：如果我重写for_each，加上引用，会不会得到我想要的效果？

3.2分析特点6（一共俩句话）

3.2.1分析保持函数的调用状态（本质是因为成员变量不会销毁）

3.2.2参数个数可变是什么意思？代码分析过程中居然用到了匿名对象！

1.分析函数对象的用法及匿名对象

2.探究匿名对象的生命周期

3.回忆匿名对象拆分开怎么写

4.讨论多参数问题（多参数不是重载函数多，而是类中多变量）

四、函数对象的分类

4.1一元函数

4.2二元函数

4.3一元判定函数

4.4二元判定函数

五、总结知识点（未完待续.....）

一、priority_queue 的介绍和使用

1.1priority_queue 的介绍

priority_queue （优先级队列）是一种容器适配器，它与 queue 共用一个头文件，其底层结构是一个堆，并且默认情况下是一个大根堆，所以它的第一个元素总是它所包含的元素中最大的，并且为了不破坏堆结构，它也不支持迭代器。

同时，由于堆需要进行下标计算，所以 priority_queue 使用 vector 作为它的默认适配容器 (支持随机访问)：

但是，priority_queue 比 queue 和 stack 多了一个模板参数 – 仿函数；关于仿函数的具体细节，我们将在后文介绍

class Compare = less<typename Container::value_type>

2.2priority_queue 的使用

优先级队列默认使用 vector 作为其底层存储数据的容器，在 vector 上又使用了堆算法将 vector 中元素构造成堆的结构，因此 priority_queue 就是堆，所有需要用到堆的位置，都可以考虑使用 priority_queue。(注意：默认情况下priority_queue是大堆)

priority_queue 的使用文档

函数声明	接口说明
priority_queue()	构造一个空的优先级队列
priority_queue(first, last)	迭代器区间构造优先级队列
empty( )	检测优先级队列是否为空
top( )	返回优先级队列中最大(最小元素)，即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大(最小)元素，即堆顶元素
size()	返回优先级队列中的元素个数

注意事项：

priority_queue 默认使用的仿函数是 less，所以默认建成的堆是大堆；如果我们想要建小堆，则需要指定仿函数为 greater，该仿函数包含在头文件 functional 中，并且由于仿函数是第三个缺省模板参数，所以如果要传递它必须先传递第二个模板参数即适配容器

void test_priority_queue() {
	priority_queue<int> pq;  //默认建大堆，仿函数为less
	pq.push(5);
	pq.push(2);
	pq.push(4);
	pq.push(1);
	pq.push(3);
	while (!pq.empty()) {
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

	priority_queue<int, vector<int>, greater<int>> pq1;  //建小堆，仿函数为greater，需要显式指定
	pq1.push(5);
	pq1.push(2);
	pq1.push(4);
	pq1.push(1);
	pq1.push(3);
	while (!pq1.empty()) {
		cout << pq1.top() << " ";
		pq1.pop();
	}
	cout << endl;
}

二、仿函数

2.1什么是仿函数

仿函数也叫函数对象，仿函数是一个类，但是该类必须重载函数调用运算符 ( )，即 operator()(参数)；由于这样的类的对象可以像函数一样去使用，所以我们将其称为仿函数/函数对象，如下：

namespace lzy {
	 class less {
    public:
		bool operator()(const int& x, const int& y) const 
    {
      cout << "less类" << endl;
			return x < y;
		}
	};
	class greater 
  {
    public:
		bool operator()(const int& x, const int& y) 
    {
      cout << "greater类" << endl;
			return x > y;
		}
	};
}
void functor_test() {
	lzy::less lessFunc;
	cout << lessFunc(1, 2) << endl;  //lessFunc.operator(1,2)

	lzy::greater greaterFunc;
	cout << greaterFunc(1, 2) << endl;  //greaterFunc.operator(1,2)
}

可以看到，因为 less 类和 greater 类重载了 () 操作符，所以类对象可以像函数一样去使用，因此它们被称为仿函数。

2.2仿函数的作用

我们以最简单的冒泡排序为例来说明仿函数的作用，我们知道，排序分为排升序和排降序，那么在没有仿函数的时候，即C语言阶段，我们是如何来解决这个问题的呢 – 答案是函数指针；

将排序函数的最后一个参数定义为函数指针，然后通过用户给排序函数传递不同的比较函数来决定升序还是降序：

但是！！在 C++ 中，我们不再使用函数指针解决升序降序的问题，转而使用更加方便的仿函数

三、函数对象的特点（知识点多）

函数对象是一个类的对象，而不是函数

函数对象是重载了operator（）的类对象

函数对象的调用格式类似于函数调用，所以也称仿函数

函数对象也具有参数和返回值

函数对象作为一个对象，可以作为参数传递给函数或其它类函数对象独有的特点

保持函数的调用状态，参数个数可变（因为函数在栈中，之后会销毁）

3.1分析特点5（比较普通函数与函数对象）

3.1.1利用普通函数传递参数

代码作用：给定成绩数组，找出大于或者小于基准值的成绩分数

#include<iostream>
using namespace std;
int baseScore = 0;
int arrSize = 5;

typedef bool (*pf) (int,int); //函数指针，是为了代码将来的可维护性 不需要修改count函数内部
int count(int grade[],pf p)//传递int int形的接口
  {
    int sum=0;
    for(int i=0;i<arrSize;++i)
    {
      if(p(baseScore,grade[i]))//难点
      {
        ++sum;
      }
    }
    return sum;
  }
 bool Cmp_big(int base,int num)// 比较函数
  {
    return num>=base;// 也可以返回整数值，设置各种比较情况
  }
  bool Cmp_small(int base,int num)// 修改比较函数
  {
    return num<=base;// 也可以返回整数值，设置各种比较情况
  }
int main()
{
  int grade[arrSize]={1,2,3,4,5};
  cout << count(grade,Cmp_big) << endl;
  return 0;
}

这里利用到了函数指针的知识点，但在这里我不想过多探讨，所以看注释就好啦

这里通过传递不同的函数比较方法，可以有不同的效果，p是一个函数指针，而函数名正好也是函数指针，所以这里重点正是cmp_big给了p，使得p变成了大于基准值比较函数（sort的第三个参数，实则正可以理解为函数指针（C语言中），在C++的话一定就是模板了）

拓展之：深度剖析函数利用模板的本质

但是在看了sort函数的底层时，我发现大部分还是用模板（谁还用函数指针啊真是）（但是C没模板，那么C一定就得用函数指针当sort函数的第三个参数了）

这样用着蛮不错的哦，但是如果我们的函数要实例化的话，你就会惊奇的发现：

这个东西长得不就是我们的函数指针吗？这也充分验证了我们函数名就是函数指针的观点！

模板的好处正是用起来爽，但其实并没有提高效率

3.1.2利用函数对象传递参数

#include<iostream>
using namespace std;
int baseScore = 0;
int arrSize = 5;
  //方法二 利用函数对象
  class cmp_obj
  {
    public:
    int base;
    bool operator()(int score) const
    {
      return (score>=base);
    }
  };
  int count(int grade[],cmp_obj cmp)//grade[i],cmp1 cmp1(grade[i]) cmp1.oprara(grade[i]);
  {
    int sum=0;
    for(int i=0;i<arrSize;++i)
    {
      if(cmp(grade[i])) //cmp.operator(grade[i]);
      {
        ++sum;
      }
    }
    return sum;
  }

int main()
{
  int grade[arrSize]={1,2,3,4,5};
  cmp_obj cmp1;
  cmp1.base=2;
  cout << count(grade,cmp1) << endl;

  cmp1.base=4;//修改基准值 
  cout << count(grade,cmp1) << endl;

  return 0;
}

分析代码：

这里没有比较函数，有的只是对象和重载operator( )，所以要修改比较规则，那么重载里面修改就好了

这正是函数对象作为一个对象，可以作为参数传递给函数或其它类函数对象独有的特点

利用函数的话，修改基准值得用全局变量，但是利用函数对象的话就不需要，这都是优势！

3.1.3函数对象作为for_each的参数（知识点较多）

1.for_each函数：

template<class InputIterator, class Function>
  Function for_each(InputIterator first, InputIterator last, Function fn) 
  //第三个参数是函数或者是函数对象
{
  while (first!=last) {
    fn (*first);//取值 传递到fn函数/函数对象
    ++first;
  }
  return fn;      //如果是函数对象 返回是有意义的 如果是函数  反而是没有意义的
}

这里重点知识点就是：for_each的第三个参数可以传递函数对象/函数

传递函数时：往往不需要接收返回值，因为接收函数没有意义

传递函数对象：一定得接收返回值，因为不接受的话因为是传值，就会丢失想要的值

2.第三个参数传递函数：（计算从0到100）

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int sum=0;
void f(int x)
{
  sum+=x;//这里是f函数 
}
int main()
{
  vector<int> v;
  for(int i=0;i<100;i++)
  {
    v.push_back(i);
  }
  //不需要接收返回值 接收函数没有意义
  for_each(v.begin(),v.end(),f);//在迭代器的范围内，每次取一个x元素，计算f(x)
  
//   for(int i=0;i<v.size();++i)
//   {
//     f(v[i]);
//   }
  cout<< sum; 
}

如果我们将for_each拆分开来：

for(int i=0;i<v.size();++i)
  {
    f(v[i]);
  }

很明显，用for_each是更爽的！只可惜有一定的使用难度成本，让我们继续往下看！

3.第三个参数传递函数对象：（计算从0到100）

//print为仿函数
class print
{
    int count;
    public:
    int get_count()
    {
        return count;
    }
    print() {count = 0;} //必须写默认构造 要不然下面匿名对象会出问题
    void operator()(int x)
    {
        cout << x << " ";
        ++count;
    }
};

在这里仿函数类中，我们用get_count函数接收私有变量，并且写好了默认构造函数，接着重载了operator( ) ，因为这个我们是用来输出的，所以返回值写成void就好了

int main()
{
    list<int> l;//初始化
    for (size_t i= 1;i<10;++i)
    {
        l.push_back(i);
    }
    //遍历ilist元素并打印
    print p = for_each(l.begin(),l.end(),print());//打印l元素个数 这里的第三个参数好好分析一下
    cout <<"count="<<p.get_count() << endl;
    return 0;
}

这里我们先对list进行了初始化，接着难点来了：

利用构造函数创建匿名对象与对象调用重载（）函数是很容易混淆的！！！

接着由于返回值是函数对象，所以可以利用p来验证最后的结果~

4.难点：关于第三个参数是传值的易错点

但是如果我不接受返回值，直接输出p1.get_count( ) ，你会不会汗流浃背呢？

这就说明，我们这里进去的值出来后就被销毁了，为了避免销毁，得加上返回值哦！

5.拓展：如果我重写for_each，加上引用，会不会得到我想要的效果？

Function& for_each(InputIterator first, InputIterator last, Function& fn) 
{
  while (first != last) {
    fn(*first);  // 取值并传递到fn函数/函数对象
    ++first;
  }
  return fn;
}

注意：类对象引用初始化的时候，一定得加上引用的是谁，类类型也是可以用引用的

3.2分析特点6（一共俩句话）

3.2.1分析保持函数的调用状态（本质是因为成员变量不会销毁）

保留函数的调用状态是什么意思呢？我们看一段代码！

int sum = 0;
void f(int x)
{
  sum += x;
}
class add
{
  int comm;
public:
  int Getsum() { return comm; }
  add() { comm = 0 ;}
  void operator()(int x)
  {
    comm += x;
  }
};
int main()
{
  int i = 0;
  for ( i = 1; i <= 100; i++)
  f(i);
  cout << sum << endl; //5050
  add fobi;
  for (i = 1;i <= 100;i++)
  fobi(i); //调用格式类似于函数
  cout << fobi.Getsum ()<< endl; //5050，保留函数状态
  return 0;
}

这段代码的知识点很多咧~ 让小羊博主一起带你们分析一波！

直观上来说，一个是普通函数，一个是重载（），那么保留函数的调用状态是什么意思？

1.本质上是因为类中的成员变量不会被销毁，但是函数中的sum与x出了作用域就会清空

2.在这俩个函数都是void的情况，为了输出最终结果，俩方势力也是煞费脑筋：

函数势力是利用了全局变量 int sum=0; 才使得得到想要结果（可惜这样是不安全的）

而重载势力是利用了共有函数接口取回最终的结果值

而且看到这个写法会不会觉得很奇怪咧，有俩个括号，意思是第一个是缺省参数吗？

不不不不，这里是重载（）函数，所以长得有些奇怪，只有第二个int x才是参数~

3.2.2参数个数可变是什么意思？代码分析过程中居然用到了匿名对象！

1.分析函数对象的用法及匿名对象

#include<iostream>
using namespace std;
class add_two
{
  int comm;
  //int hehe;
  public:
  int Getsum() { return comm; } 
  add_two()
  { comm = 0;}
  add_two(int v) { comm = v;}
  int operator()(int x) //不是说这个是特殊语法 是因为operator*(int x) 等等重载函数都是这么写的
  {
    return (comm + x );
  }

};
void test1()
{
int ret = add_two()(2); //利用匿名对象
cout << ret << endl;// ret=2;

ret = add_two(5)(2);//ret=7;
cout << ret << endl;

ret = add_two(6)(2);//ret=8;
cout << ret << endl; 

}
int main()
{
  test1();
  return 0;
}

代码分析：

还是老样子，在类中依然重载了operator( ) , 所以让我们看看主函数是怎么调用的吧

类中有俩个构造函数，一个是有参，一个是无参（并且给了默认值是0）

（吐槽：直接给缺省不就行了，还写俩个构造函数）

add_two()：虽然是俩个括号但是第一个是构造函数然后用了匿名对象的知识点！！！！这部分创建了一个 add_two 的匿名对象（生命周期只有一行），使用了默认构造函数，该构造函数将 comm 成员初始化为 0。这个对象实际上是一个函数对象（因为我们重载了operator（），所以对象后面跟上括号，自然而然就会去调用重载函数去了），因为我们可以调用它。

接下来，像调用函数一样传递了一个整数参数 2 给这个匿名对象。由于 add_two 类重载了 operator()，因此可以将它视为函数调用。

int ret = ...：最后，将这个函数对象调用的结果（在这种情况下是 0 + 2 = 2）赋值给整数变量 ret。

所以，int ret = add_two()(2); 的含义是创建一个 add_two 的匿名对象，然后将其当做函数调用，将参数 2 传递给它，最后将结果 2 赋给 ret。这展示了函数对象的使用，允许像调用函数一样使用类的实例。

但如果想充分发挥函数对象的作用的话，其实我们可以直接输出：

2.探究匿名对象的生命周期

//讲解匿名对象
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor" << std::endl;
    }

    ~MyClass() {
        std::cout << "MyClass destructor" << std::endl;
    }
};

int main() {
    cout << "flag1" << endl;
    MyClass();  // 创建匿名对象 匿名对象的生命周期只有这一行
    cout << "flag2" << endl;
    return 0;
}

匿名对象的生命周期只有创建的那一行，走了之后就会被销毁掉！

3.回忆匿名对象拆分开怎么写

好了，我们了解完匿名对象的知识点后，让我们来回忆一下上面那个例子拆分开来是什么效果

//int tmp=add_two(100);
add_two addFunction(100); // 创建一个 add_two 对象
ret = addFunction(2); // 调用对象的 operator()，传递参数 2
cout << ret << endl;

4.讨论多参数问题（多参数不是重载函数多，而是类中多变量）

#include <iostream>

// 基本情况：当没有参数时，返回0
int sum() {
    return 0;
}

// 使用可变参数模板来计算总和
template <typename T, typename... Args>
T sum(T first, Args... rest) {
    return first + sum(rest...);
}

int main() {
    int result = sum(1, 2, 3, 4, 5);
    std::cout << "Sum: " << result << std::endl;

    double result2 = sum(1.1, 2.2, 3.3, 4.4);
    std::cout << "Sum: " << result2 << std::endl;

    return 0;
}

四、函数对象的分类

函数对象是重载了operator() 的类的一个实例，operator()是函数调用运算符。

标准C++库根据 operator() 参数个数为0个，1个，2个加以划分的。要有以下3种类型：

发生器:一种没有参数且返回一个任意类型值的函数对象，例如随机数发生器。

一元函数:一种只有一个任意类型的参数，且返回-个可能不同类型值的函数对象。

二元函数:一种有两个任意类型的参数，且返回一个任意类型值的函数对象。

一元判定函数: 返回bool型值的一元函数

二元判定函数: 返回bool型值的二元函数

4.1一元函数

templat<typename _A,typename _R>
class unary_function
{
    typedef _A argument_type;

    typedef _R result_type;      
};

有俩个模板参数第一个是输出参数参数类型第二个模板参数定义为结果类型返回类型动态特性非常强

p62 即使类中从来没有用过但是还是可以定义用（意思是，这个基类是在上面的类继承下来的，所以说它的arg也可以当成输出参数，即使我们的基类没有写）

P62页代码：

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;
template<typename _A, typename _R>
struct unary {
	typedef _A argument_type;
	typedef _R result_type;
};


template<typename _inPara, typename _outPara>//邸老师说 希望这里删去
class CSum : public unary<_inPara, _outPara> {
public:
	_outPara sum;//这里可以使用 result_type;
	CSum() { sum = 0; }
	void operator()(_inPara n) { sum += n; } //这里同理也可以用 argument_type;
	_outPara GetSum() { return sum; }
};
template<typename _input>
class CPrint
{
    public://这个记得加
    CPrint(){};
    void operator()(_input var)
    {
        cout << var << " ";
    }
};
int main() 
{
    //传int
	vector<int> v;
	for (int i = 1;i <= 5;i++) { v.push_back(i); }
    //遍历int
    vector<int>::iterator it=v.begin();
    for(;it!=v.end();++it)
    {
        cout << *it << " ";//这样遍历 可以防止出界 比那个[]遍历更安全
    }cout << endl;

	CSum<int, int> sobj = for_each(v.begin(), v.end(), CSum<int, int>());//类的显示实例化+匿名对象
	cout << "sum(int)=" << sobj.GetSum() << endl;


    //传float
	vector<float> v2;
	float f = 1.3f;
	for (int i = 1;i <= 5;i++) { 
		v2.push_back(f); 
		f += 1.0f; 
	}
    //遍历float
    vector<float>::iterator it1=v2.begin();
    for(;it1!=v2.end();++it1)
    {
        cout << *it1 << " ";//这样遍历 可以防止出界 比那个[]遍历更安全
    }cout << endl;
    
	CSum<float, float> sobj2 = for_each(v2.begin(), v2.end(), CSum<float, float>());
	cout << "sum(float)=" << sobj2.GetSum() << endl;

    //利用CPrint函数对象 与 for_each代替迭代器输出
    vector<int>v3={1,2,3,4,5};
    for_each(v3.begin(), v3.end(), CPrint<int>());
    cout << endl;
    //同理
     vector<float>v4={1.1,2.1,3.1,4.1,5.1};
    for_each(v4.begin(), v4.end(), CPrint<float>());

    //lambad表达式
    
	return 0;
}