精华内容
下载资源
问答
  • 仿函数
    千次阅读
    2020-07-31 17:11:11

    仿函数:funtor,就是是一个类的使用看上去像一个函数。其实现就是类中实现一个operator(),这个类就有了类似函数的行为,就是一个放函数类了。
    STL组件:使用方式类似于函数的类–>重载圆括号"()"的运算符重载函数
    仿函数对象:由仿函数类创建的对象

    容器适配器:STL组件
    stack,queue,priority_queue
    通过适配器的设计模式定义的新的数据结构
    适配器:把一种接口转换为另一种接口的方法(其他容器经过再封装)
    例如:stack,queue,priotiry_queue等都是线性表,只是受到限制的线性表

    stack : template<class T,class Container = deque<T>> class stack ;
    queue:template<class T,class Container = deque<T>> class queue ;
    priority_queue:template<class T,class Container = vector<T> , class Compare = less<typename Container::value_type>> class priority_queue ;
    

    stack:
    实现:vector,list,deque都可以实现stack
    stack实现规范:默认实现deque
    1、只要容器含有以下接口,都可以作为stack的底层容器
    push_back --> push
    pop_back --> pop
    front --> top
    size --> size
    empty --> empty

    queue:
    实现:list,deque,默认实现deque
    queue实现规范:只要包含以下接口都可以用于实现队列
    push_back --> push
    pop_front --> pop
    front --> front
    back --> back
    size – > size
    empty – > empty

    vector不能实现queue,因为其不提供pop_front接口

    priority_queue:vector,deque可以实现优先级队列
    容器提供以下接口且可以满足随机访问(list不支持随机访问,因此不能实现priority_queue)(默认实现vector)
    push_back --> push
    pop_back --> pop
    front --> top
    size --> size
    empty --> empty
    list不能实现priority_queue,不支持随机访问

    #define _CRT_SECURE_NO_WARNINGS 1
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include "Stack.h"
    #include <cmath>
    #include <string>
    // 无序的map
    #include <unordered_map>
    #include <map>
    #include <unordered_set>
    #include <set>
    #include <queue>
    //#include <priority_queue>
    using namespace std;
    
    //void testPriorityQueue()
    //{
    //	// 通过堆实现,默认为大堆
    //	// 抛出的时候从大到小抛出
    //	priority_queue<int> pq;
    //	pq.push(10);
    //	pq.push(110);
    //	pq.push(120);
    //	pq.push(1);
    //	pq.push(18);
    //
    //	while (!pq.empty())
    //	{
    //		cout << pq.top() << " ";
    //		pq.pop();
    //	}
    //	cout << endl;
    //}
    
    struct A{
    	A(int a = 0, int b = 0, int c = 0)
    		:_a(a)
    		, _b(b)
    		, _c(c)
    	{}
    	//bool operator < (const A& aa) const
    	//{
    	//	return _a < aa._a;
    	//}
    
    	bool operator > (const A& a) const
    	{
    		return _a > a._a;
    	}
    	int _a;
    	int _b;
    	int _c;
    };
    
    ostream& operator<<(ostream& cout, const A& c)
    {
    	cout << c._a << "-" << c._b << "-" << c._c << endl;
    	return cout;
    }
    
    // 仿函数类模板
    template<class T>
    struct Less
    {
    	// 重载括号运算符
    	bool operator()(const T& a, const T& b) const
    	{
    		return a > b;
    	}
    };
    void test1(){
    	//优先级队列存放自定义类型,自定义类型需要支持大小比较运算
    
    	// 建大堆,需要提供小于的比较
    	//priority_queue<A> aq;
    
    	//aq.push(A(1, 2, 3));
    	//aq.push(A(0, 1, 8));
    	//aq.push(A(2, 0, 6));
    	//aq.push(A(5, 3, 4));
    	//aq.push(A(7, 9, 3));
    
    	// 建小堆:需要仿函数组件
    	Less<A> la;
    	A a1(1, 2, 3);
    	A a2(2, 2, 3);
    	bool ret = la.operator()(a1, a2);
    	cout << ret << endl;
    	priority_queue<A> aq;
    
    	aq.push(A(1, 2, 3));
    	aq.push(A(0, 1, 8));
    	aq.push(A(2, 0, 6));
    	aq.push(A(5, 3, 4));
    	aq.push(A(7, 9, 3));
    
    
    	while (!aq.empty())
    	{
    		cout << aq.top();
    		aq.pop();
    	}
    
    }
    int main(){
    	test1();
    	//testPriorityQueue();
    	system("pause");
    	return 0;
    }
    
    更多相关内容
  • 浅析C++ 仿函数

    2021-01-19 23:42:23
    1.为什么要有仿函数 我们先从一个非常简单的问题入手。假设我们现在有一个数组,数组中存有任意数量的数字,我们希望能够计数出这个数组中大于10的数字的数量,你的代码很可能是这样的: #include using namespace...
  • 有序的stl容器在工程中应用什么方便和广泛,但是当我们需要自己的排序的时候,可以用仿函数来设置它
  •  本委托库支持普通函数,仿函数,类成员函数的委托库,以相同方式声明0-9个参数的任意委托。  特点:  一、支持编译器和性能,这包括VC6.0和VC7.1:  只使用了STL的vector和typeinfo库.性能与boost的function...
  • C++仿函数

    千次阅读 2022-04-25 10:05:01
    1.STL中提供的仿函数 2.仿函数一些简单用法示例

    1.仿函数定义

    顾名思义,就是"仿造函数"的意思,它并不是函数,但是却有着类似于函数的行为. 我们在编程的时候,有时候会发现这样一种情况:有一些相同的功能,会在不同的成员函数中出现. 这时候按照一般的技巧,我们会将这些相同的功能独立出来进行封装. 但是写一个公共函数的话,函数用到的一些变量就可能被迫成为公共的全局变量. 而且,仅仅为了复用这一片代码,就要单独写一个函数,也不是很好维护,这个时候就可以用仿函数了. 按照百度词条的说法:写一个简单的类,除了那些维护一个类的成员函数外,就只是实现一个operator(),在类实例化的时候,就将要用的,非参数的元素传入类中. 这样就免去了一些公共变量的全局化的维护了. 又可以使那些代码独立出来,以便下次复用. 而且这些仿函数,还可以用关联,聚合,以来的类之间的关系,与用到他们的类组合在一起,这样有利于资源的管理.

    2.STL中提供的仿函数

    3.优点

    将一个个功能通过类来实现,大多数情况下会加大代码量. 仿函数也是如此,但是仿函数却有着许多优点,
    除了上述的有利于资源管理、有利于代码维护外,还具有这些特点
    (1)智能性:仿函数是通过仿函数类来实现的,既然是类,里面就可以储存许多变量还有其他的一些信息.
       我们可以利用这个特征实现许多纯的函数实现不了的功能,举个简单的例子:我若再仿函数中加入了
       统计调用函数次数的功能。那么在我使用仿函数的时候,就可以自动实现统计次数的功能. 所以说,
       它更加智能.
    (2)灵活性:或者说,每个仿函数都可以有自己的类型. 由于仿函数是泛型编程的一个例证, 它可以任意
       指定类型。
    (3)通常比一般函数速度更快:尤其是大量调用函数的过程中. 比如说:STL排序的时候,所需要的那个排
       序规则(为一个bool型的函数).

    4.示例

    4.1 仿函数实现的一个简单示例

    #include <iostream>
    using namespace std;
    class Compare
    {
    public:
        bool operator()(int a, int b)
        {
            return a < b;
        }
    };
    template <class Function>
    void comp(int a, int b, Function func)
    {
        if (func(a, b))
        {
            cout << b << " is bigger than " << a << endl;
        }
        else
        {
            cout << a << " is bigger than " << b << endl;
        }
    }
    int main()
    {
        int a = 6;
        int b = 2;
        Compare com;
        comp(a, b, com);
    }

    4.2 STL中的less<T>的一个用法示例

    /* 
    /home/muten003/CPP/functor/002.cpp
    */
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    class MyClass
    {
    public:
        int x;
        int y;
        friend bool operator<(MyClass a, MyClass b);
    };
    
    class Compare
    {
        friend bool operator<(MyClass a, MyClass b)
        {
            return a.x < b.x;
        }
    };
    
    int main()
    {
        less<MyClass> myclassLes;
        MyClass myclass[3];
        myclass[0].x = 2;
        myclass[1].x = 1;
        myclass[2].x = 3;
        sort(myclass, myclass + 2, myclassLes);
        cout << myclass[0].x << " " << myclass[1].x << " " << myclass[2].x << endl;
    }

    展开全文
  • 【C++】回调函数与仿函数

    千次阅读 2021-11-28 18:31:54
    C++学习笔记–回调函数与仿函数 文章目录C++学习笔记--回调函数与仿函数一、回调函数1.定义2.例子函数指针利用函数指针实现回调函数二、仿函数1.定义2.使用仿函数来实现回调函数总结使用回调函数(函数指针实现)与...

    C++学习笔记–回调函数与仿函数

    一、回调函数

    1.定义

    我们先看百度百科定义:回调函数就是一个被作为参数传递的函数。在C语言中,回调函数只能使用函数指针实现,在C++、Python、ECMAScript等更现代的编程语言中还可以使用仿函数或匿名函数
    为什么需要一个被作为参数传递的函数? 在实际需求中,往往在一个任务中有多个步骤,但每个步骤又具有不确定的约束,在程序执行到某一个步骤时需要一个约束,而这个约束我们希望不将他写死,交给使用者来决定。举个例子,我们需要对一个数组排序,排序规则由用户在调用排序方法时确定(从大到小或者从小到大),这时可定义一个回调函数作为排序方法的参数之一。

    2.例子

    我们首先看STL中的sort算法的回调函数使用:

    sort(a.begin(), a.end(), compareUp());
    

    其中compareUp()为自定义的仿函数,用来指定排序规则为从小到大。下面我们自己实现使用回调函数和仿函数定义排序规则,以冒泡排序为例。

    函数指针

    前面定义说到,在C语言中使用函数指针来实现回调函数,我们先来看看什么是函数指针。函数指针是指向函数的指针变量,即首先它是一个指针变量,我们可以将函数的地址传给指针变量,通道指针来间接调用函数。

    bool (*compare)(int, int);//函数指针定义
    

    compare是一个指针,它指向一个参数列表类型为(int, int), 返回值为bool类型的函数,我们可以对它进行初始化:

    compare=compareUp;
    

    或者

    compare=&compareUp;
    

    compareUp是一个确定的函数,我们将这个函数的地址赋给函数指针。

    利用函数指针实现回调函数

    首先我们定义两个排序规则的函数:

    //回调函数 从小到大排序
    inline bool compareUp(int& val1, int& val2)//声明为内联函数可以加快调用速度
    {
    	if (val1>val2)
    	{
    		return true;
    	}
    	return false;
    }
    //回调函数 从大到小排序
    inline bool compareDown(int& val1, int& val2)
    {
    	if (val1 < val2)
    	{
    		return true;
    	}
    	return false;
    }
    

    实现冒泡排序的函数:

    void bubbleSort(vector<int>& arr, bool (*compare)(int&, int&))//将函数指针作为排序函数的参数,它接收一个函数的地址
    {
    	for (int i = 0; i < arr.size(); i++)
    	{
    		for (int j = i + 1; j < arr.size(); j++)
    		{
    			if (compare(arr[i], arr[j]))
    			{
    				int tmp = arr[i];
    				arr[i] = arr[j];
    				arr[j] = tmp;
    			}
    		}
    	}
    }
    

    测试我们的冒泡排序,先定义一个打印vector<int>类型的函数printVectotInt

    void printVectorInt(vector<int>& v) {
    	for (vector<int>::iterator it=v.begin();it!=v.end();it++)//遍历打印vector
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    

    测试:

    void test01() {
    	vector<int>a = { 2,3,5,7,12,34,16,8,17 };
    	bubbleSort(a, compareUp);
    	printVectorInt(a);
    	bubbleSort(a, compareDown);
    	printVectorInt(a);
    }
    int main() {
    
    	test01();
    	system("pause");
    	return EXIT_SUCCESS;
    }
    

    结果
    在这里插入图片描述
    另外,在我们不想声明定义一个过于简单的函数时,可以使用lambda表达式(匿名函数),匿名函数也可以传入函数指针中使用:

    void test02() {
    	//使用匿名函数作为函数指针
    	vector<int>b = { 9,3,5,23,12,34,16,8,20 };
    	cout << "从小到大排序(匿名函数)" << endl;
    	bubbleSort(b, [](int& v1, int& v2) { return v1 > v2 ? true : false; });
    	printVectorInt(b);
    }
    

    在这里插入图片描述

    二、仿函数

    1.定义

    顾名思义,仿函数即仿照的函数,表示它功能与函数类似但并不是真正的函数,仿函数又叫函数对象。在C++中它通过重载函数调用运算符即 ()运算符,还是以排序规则为例:

    //定义排序规则的仿函数类--从小到大
    class compareUp
    {
    public:
    	bool operator()(const int& val1, const int& val2) const {//定义为常函数
    		if (val1>val2)
    		{
    			return true;
    		}
    		return false;
    	}
    };
    //定义排序规则的仿函数类--从大到小
    class compareDown
    {
    public:
    	bool operator()(const int& val1, const int& val2) const {
    		if (val1 < val2)
    		{
    			return true;
    		}
    		return false;
    	}
    };
    

    在仿函数的类中,通常不需要定义构造函数和析构函数,这将由系统帮我们自动完成。值得一提的是,我们最好将重载()的函数定义为常函数,这表明我们并不会改变传入的参数,避免一些麻烦。

    2.使用仿函数来实现回调函数

    下面使用仿函数来实现回调,我们定义一个compareUp或compareDown的匿名对象作为冒泡排序函数的参数。由于我们事先不知道传入的是什么类,所以实现排序函数需要使用模板函数:

    template<class T>
    void bubbleSort(vector<int>& arr, const T& compare) {
    	for (int i = 0; i < arr.size(); i++)
    	{
    		for (int j = i + 1; j < arr.size(); j++)
    		{
    			if (compare(arr[i], arr[j]))
    			{
    				int tmp = arr[i];
    				arr[i] = arr[j];
    				arr[j] = tmp;
    			}
    		}
    	}
    }
    

    测试:

    void test01() {
    	vector<int>a= { 2,3,5,7,12,34,16,8,17 };
    	cout << "从小到大排序: " << endl;
    	bubbleSort(a, compareDown());//仿函数是一个匿名对象
    	printVectorInt(a);
    	cout << "从大到小排序: " << endl;
    	bubbleSort(a, compareUp());
    	printVectorInt(a);
    }
    int main() {
    
    	test01();
    	system("pause");
    	return EXIT_SUCCESS;
    }
    

    结果:
    在这里插入图片描述

    总结

    使用回调函数(函数指针实现)与使用仿函数优缺点比较

    1.当需要回调的功能函数比较简单时,通常声明为内联函数,这时函数调用将被展开,此时与仿函数性能差别不大;但是使用函数指针实现的回调函数它终究是函数,如果我们需要保留某些状态,这时函数无法实现,因为在函数调用结束后,内部数据都被释放了。而仿函数可以做到这一点,例如我们需要实现记录某一个回调逻辑在程序运行中被调用了多少次,这在普通函数内只能通过一些外部的静态变量来实现;而在仿函数中,我们可以通过给类添加属性,来记录一些状态,而不是使用外部的变量。
    2.当需要回调的功能函数比较复杂时,此时回调函数作为一个函数指针传入,其代码亦无法展开。而仿函数则不同。虽然功能函数本身复杂不能展开,但是对仿函数的调用是编译器编译期间就可以确定并进行inline展开的。因此在这种情形下,仿函数比之于回调函数,有着更好的性能。

    参考
    [1]: http://blog.csdn.net/xushiweizh/article/details/1519828
    [2]: https://baike.baidu.com/item/%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0/7545973?fr=aladdin

    展开全文
  • 【C++】优先级队列priority_queue模拟实现&&仿函数

    多人点赞 热门讨论 2022-04-07 10:01:02
    详细介绍priority_queue优先级队列的模拟实现,以及基础仿函数的介绍使用

    往期回顾:上一篇文章已经模拟实现过stack和queue,三者都是容器适配器Container adaptors
    stack&&queue&&deque
    在这里插入图片描述

    🍂前言

    优先级队列:根据严格的弱排序标准,第一个元素总是优先级最高的,而优先级是相对而言的,并不是大的数优先级就高,就成绩而言100比90高,但A比B高。
    priority_queue的底层是一个堆,默认是大堆,堆顶的元素(最大的数)优先级最高
    在这里插入图片描述因为堆是完全二叉树,默认是由vector实现的,Compare是一个仿函数,用来控制priority_queue的优先级,默认为less(大堆),也可以传greater变为小堆
    在这里插入图片描述

    🍂大致框架

    在这里插入图片描述

    我们先不管仿函数,只定义两个模板参数实现成大堆
    #pragma once
    #include <iostream>
    #include <vector>
    using namespace std;
    namespace king
    {
    	template<class T, class Container=vector<T>>
    	class priority_queue
    	{
    	public:
    		//迭代器区间初始化的构造函数
    		template<class InputIterator>
    		priority_queue(InputIterator first,InputIterator last)
    			:_con(first,last)
    		{}
    		//无参的构造函数
    		priority_queue()
    		{}
    		//插入(尾插)
    		void push(const T& x);
    		//删除(变相头删,交换头尾再尾删)
    		void pop();
    		//返回容器有效元素个数
    		size_t size() const;
    		//返回堆顶元素
    		T& top();
    		//判空
    		bool empty();
    	private:
    		Container _con;//默认是vector<T> _con;
    	};
    }
    

    🍂模拟实现

    🌌size、top、empty

    因为priority_queue是容器适配器,所以直接调用其他容器的接口即可
    size_t size() const
    {
    	return _con.size();
    }
    T& top()
    {
    	return _con[0];
    }
    bool empty()
    {
    	return _con.empty();
    }
    

    相关文章:
    堆的模拟实现
    因为是底层是一个堆,所以主要的两个函数就是向上调整和向下调整

    🌌push插入

    void AdjustUp(size_t child)
    {
    	size_t parent = (child - 1) / 2;
    	while (child > 0)
    	{	
    		//因为是大堆,所以孩子大于父亲就交换std::swap
    		if (_con[child] > _con[parent])
    		{
    			swap(_con[child], _con[parent]);
    			child = parent;
    			parent = (child - 1) / 2;
    		}
    		else
    			break;
    	}
    }
    void push(const T& x)
    {
    	_con.push_back(x);//直接调用容器_con的push_back
    	AdjustUp(size()-1);
    }
    

    🌌pop删除

    void AdjustDown(size_t parent)
    {
    	size_t child = parent * 2 + 1;//左孩子
    	while (child < size())
    	{	
    		//判断是否有右孩子,且右孩子大于左孩子
    		if (child + 1 < size() && _con[child + 1] > _con[child])
    			++child;
    		if (_con[child] > _con[parent])
    			swap(_con[parent], _con[child]);
    		else
    			break;
    		parent = child;
    		child = parent * 2 + 1;
    	}
    }
    void pop()
    {	
    	//头尾交换再尾删(头删)
    	swap(_con[size() - 1], _con[0]);
    	_con.pop_back();
    	AdjustDown(0);
    }
    

    🌌构造函数

    用迭代器区间初始化,插入到_con容器后,需要把它变成一个大堆,所以从最后一个非叶子节点(最后一个叶子节点的父亲)开始向下调整
    相关文章:TopK问题和堆排序

    //_con在初始化列表就会自动调用它的默认构造函数初始化
    priority_queue()
    {}
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last)
    	:_con(first, last)
    {
    	size_t lastchild = size() - 1;
    	size_t parent = (lastchild - 1) / 2;
    	for (size_t i = parent; i >= 0; i--)
    	{
    		AdjustDown(i);
    	}
    }
    

    🌌测试

    void priority_test1()
    {
    	priority_queue<int> pq;
    	pq.push(40);
    	pq.push(30);
    	pq.push(56);
    	pq.push(26);
    	pq.push(45);
    	while (!pq.empty())
    	{
    		cout << pq.top() << " ";
    		pq.pop();
    	}
    	cout << endl;
    }
    

    默认是大堆,大的优先级高
    在这里插入图片描述

    🪐仿函数

    仿函数本质就是重载了一个operator(),创建一个行为类似函数的对象,我们可以通过这个对象调整优先级队列是大堆还是小堆,调用STL中的仿函数需要包头文件#inclide <functional>
    在这里插入图片描述和C语言的函数指针类似,qsort就需要一个函数指针来判定排升序还是降序,但仿函数比函数指针更加灵活。当然这只是最基本的仿函数,之后的文章也会深入介绍

    struct Less
    {
    	bool operator()(const int& a, const int& b) const
    	{
    		return a < b;
    	}
    };
    struct Greater
    {
    	bool operator()(const int& a, const int& b)const
    	{
    		return a > b;
    	}
    };
    int main()
    {
    	//Less->仿函数类型	ls->仿函数对象
    	Less ls;
    	//ls.operator()(1,2)
    	cout << ls(1, 2) << endl;
    	cout << Greater()(1, 2) << endl;//匿名对象
    }
    

    在这里插入图片描述

    我们就可以根据仿函数Compare是less还是greater,调整向上和向下调整算法,进而实现大小堆的切换
    在这里插入图片描述
    在这里插入图片描述向下调整也是如此,这样就可以传greater建小堆了

    🪐测试

    在这里插入图片描述

    🪐源码

    priority_queue.h

    #pragma once
    #include <iostream>
    #include <vector>
    using namespace std;
    namespace king
    {	
    	template<class T>
    	struct less
    	{
    		bool operator()(const T& a, const T& b)
    		{
    			return a < b;
    		}
    	};
    	template<class T>
    	struct greater
    	{
    		bool operator()(const T& a, const T& b)
    		{
    			return a > b;
    		}
    	};
    	template<class T, class Container = vector<T>, class Compare=less<T>>
    	class priority_queue
    	{
    	private:
    		Compare com;
    		void AdjustUp(size_t child)
    		{
    			size_t parent = (child - 1) / 2;
    			while (child > 0)
    			{
    				//if (_con[child] > _con[parent])->父亲小于孩子就调整
    				if (com(_con[parent], _con[child]))//
    				{
    					swap(_con[child], _con[parent]);
    					child = parent;
    					parent = (child - 1) / 2;
    				}
    				else
    					break;
    			}
    		}
    		void AdjustDown(size_t parent)
    		{
    			size_t child = parent * 2 + 1;
    			while (child < size())
    			{
    				//if (child + 1 < size() && _con[child + 1] > _con[child])
    				if (child + 1 < size() &&  com(_con[child], _con[child + 1]))
    					++child;
    				//if (_con[child] > _con[parent])
    				if (com(_con[parent], _con[child]))
    					swap(_con[parent], _con[child]);
    				else
    					break;
    				parent = child;
    				child = parent * 2 + 1;
    			}
    		}
    	public:
    		priority_queue()
    		{}
    		template<class InputIterator>
    		priority_queue(InputIterator first, InputIterator last)
    			:_con(first, last)
    		{
    			size_t lastchild = size() - 1;
    			size_t parent = (lastchild - 1) / 2;
    			for (size_t i = parent; i >= 0; i--)
    			{
    				AdjustDown(i);
    			}
    		}
    		void push(const T& x)
    		{
    			_con.push_back(x);
    			AdjustUp(size() - 1);
    		}
    		void pop()
    		{
    			swap(_con[size() - 1], _con[0]);
    			_con.pop_back();
    			AdjustDown(0);
    		}
    		size_t size() const
    		{
    			return _con.size();
    		}
    		T& top()
    		{
    			return _con[0];
    		}
    		bool empty()
    		{
    			return _con.empty();
    		}
    	private:
    		Container _con;
    	};
    	void priority_test1()
    	{
    		priority_queue<int> pq;
    		pq.push(40);
    		pq.push(30);
    		pq.push(56);
    		pq.push(26);
    		pq.push(45);
    		while (!pq.empty())
    		{
    			cout << pq.top() << " ";
    			pq.pop();
    		}
    		cout << endl;
    	}
    	void priority_test2()
    	{
    		priority_queue<int, vector<int>, greater<int>> pq;
    		pq.push(40);
    		pq.push(30);
    		pq.push(56);
    		pq.push(26);
    		pq.push(45);
    		cout << "greater<int>建小堆-->  ";
    		while (!pq.empty())
    		{
    			cout << pq.top() << " ";
    			pq.pop();
    		}
    		cout << endl;
    		priority_queue<int> pq2;
    		pq2.push(40);
    		pq2.push(30);
    		pq2.push(56);
    		pq2.push(26);
    		pq2.push(45);
    		cout << "默认less<int>建大堆-->  ";
    		while (!pq2.empty())
    		{
    			cout << pq2.top() << " ";
    			pq2.pop();
    		}
    		cout << endl;
    	}
    }
    

    test.cpp

    #include "priority_queue.h"
    
    int main()
    {	
    	king::priority_test2();
    
    	return 0;
    }
    

    以上就是STL中优先级队列priority_queue的模拟实现以及最基础的仿函数了,希望我的文章对你有所帮助,欢迎👍点赞 ,📝评论,🌟关注,⭐️收藏

    在这里插入图片描述

    展开全文
  • C++基础之仿函数和lambda表达式

    千次阅读 2022-04-08 15:39:37
    一、仿函数 我们先从一个非常简单的问题入手,来了解为什么要有仿函数。 假设我们现在有一个数组,数组中存有任意数量的数字,我们希望能够统计出这个数组中大于 10 的数字的数量,你的代码很可能是这样的: ...
  • C++笔记 STL 仿函数

    2022-03-30 16:57:28
    最近再看STL源码的时候看到里面的实现用了大量的仿函数,然后上网搜集了一些关于仿函数的知识。 Functor(仿函数), 或者称之为function object(函数对象), 是STL的四大组件之一。仿函数是一个能行使函数功能的...
  • C++之仿函数

    千次阅读 多人点赞 2019-09-20 20:57:36
    最近再看STL源码的时候看到里面的实现用了大量的仿函数,然后上网搜集了一些关于仿函数的知识。 仿函数(Functor)又称为函数对象(Function Object)是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数...
  • C++ 仿函数

    万次阅读 多人点赞 2018-09-23 01:12:49
    1.为什么要有仿函数 我们先从一个非常简单的问题入手。假设我们现在有一个数组,数组中存有任意数量的数字,我们希望能够计数出这个数组中大于10的数字的数量,你的代码很可能是这样的: #include &amp;amp;...
  • C++知识点——仿函数

    千次阅读 2022-05-10 17:15:21
    仿函数,并不是函数,却有着类似于函数的行为,简单地说就是重载括号运算符号。 把对象当作一个函数用 仿函数拥有自己的数据成员,意味着仿函数拥有状态; #include<iostream> #include<algorithm> ...
  • C++STL之仿函数

    2022-03-29 00:10:15
    仿函数分为三种:算术仿函数,关系仿函数和逻辑仿函数。下面我们来一一讲解吧 1.算术仿函数: 2.关系仿函数: 小技巧:利用functional头文件种的greater函数就可以省去前面的构造类函数mycompare。方便了...
  • 详解STL之仿函数

    2020-08-16 18:01:50
    仿函数(函数对象)概观 仿函数的通俗定义:仿函数(functor)又称为函数对象(function object)是一个能行使函数功能的类。仿函数的语法几乎和普通函数调用一样,不过作为仿函数的类,都必须重载 operator() ...
  • C++中 仿函数简单介绍

    2021-03-20 14:40:19
    仿函数,顾名思义,就是“仿造函数”的意思,它并不是函数,但是却有着类似于函数的行为。那么,它到底是什么? 首先要说的是:仿函数是泛型编程强大威力和纯粹抽象概念的又一个例证。我们在C++最早接触泛型编程的...
  • 重载函数调用操作符的类,其对象称为函数对象(function object),即他们是行为类似函数的对象,也叫仿函数(functor),其实就是重载“()”操作符,使类对象可以向函数那样调用。 函数对象(仿函数)是一个类,...
  • 主要介绍了c++11 符号修饰与函数签名、函数指针、匿名函数、仿函数、std::function与std::bind,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • c++ 仿函数的使用

    2020-09-21 14:58:38
    看上去像一个函数, 其实是一个类。 在通俗一点就是, 操作符重载函数 operator()() 第一种 重载() operator() lambda 表达式 用途: 在c++ STL算法中 经常会用到。 比如 count_if, find_if 如下代码 #include ...
  • STL之仿函数实现详解

    万次阅读 多人点赞 2018-03-28 21:34:19
    1、何为仿函数 仿函数的主要功能是为了搭配STL算法使用,单独使用仿函数的情况比较少。 仿函数(functors)在C++标准中采用的名称是函数对象(function objects)。仿函数主要用于STL中的算法中,虽然函数指针虽然...
  • 什么是仿函数

    2021-09-27 16:05:47
    先来看仿函数的通俗定义:仿函数(functor)又称为函数对象(function object)是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样,不过作为仿函数的类,都必须重载operator()运算符,举个例子:...
  • 仿函数、函数对象 函数对象,即一个重载了括号操作符“()”的对象。当用该对象调用此操作符时,其表现形式如同普通函数调用一般,因此取名叫函数对象。即重载函数调用操作符的类,其对象通常称为函数对象。函数...
  • 文章目录系列文章目录前言一、仿函数1.定义2.特点二、仿函数使用1.基本使用2.要求打出小于5的值结合模板使用总结 前言 C++ 这门编程语言的历史可以追溯至 1979 年,当时的 Bjarne Stroustrup(C++ 之父,后续简称 ...
  • 仿函数实现set容器自定义排序C++
  • 回调函数 回调函数是C语言中就有的一种函数。根据百度百科回调函数的定义:回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,...
  • STL源码之仿函数

    2018-12-10 00:02:20
    本节将分析STL六部分之一的仿函数, 在前面分析容器以及算法的时候都有使用过仿函数, 在算法中我们还自定义过仿函数(函数对象), 就是使用struct或者class重载运算符, 就是行为类似于函数的对象. 根据仿函数的操作数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,570
精华内容 55,028
关键字:

仿函数

友情链接: JSFandSDO.rar