C++ 仿函数

仿函数定义 

 仿函数本质上就是类+operator（）

看上去仿佛是函数 实际是类

仿函数比函数更灵活 有自己的数据和成员变量

仿函数可以当作参数传递

仿函数比函数指针执行的更快（大多数情况下）

仿函数可以当作模板使用，因为每个仿函数都拥有自己的类型

仿函数返回值类型是bool数据类型 称为谓词

如果operator接受一个参数  就是一元谓词

接收两个参数就是二元谓词

缺点在于定义的时候需要定义在一个类里面

#include<iostream>
using namespace std;
class Print
{
public:
	int operator()(int a)
	{
		cout << a <<" "<<++count << endl;
		return a;
	}
private:
	int count = 0;
};

//作为参数传递
Print add(Print a)
{
	return a;
}

template<class Brin>
Brin bdd(Brin a)
{
	return a;
}

template<class Crin>
Crin cdd(Crin a)
{
	return a;
}


int main(void)
{
	Print aaa;
	int a = 4;
	aaa(a);
//作为参数传递
	add(aaa);
	bdd<Print>(aaa);
	cdd(aaa);
	return 0;
}

我们在有些情况下 必须要用仿函数

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{
	}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d);
private:
	int _year;
	int _month;
	int _day;
};

struct LessPDate
{
	bool operator()(const Date* p1, const Date* p2)
	{
		return *p1 < *p2;
	}
};

		void test_priority_queue2()
	{

		priority_queue<Date*, vector<Date*>, LessPDate> pq;
		pq.push(new Date(2023, 7, 20));
		pq.push(new Date(2023, 6, 20));
		pq.push(new Date(2023, 8, 20));

		while (!pq.empty())
		{
			cout << *pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}
}



int main(void)
{
	bit::test_priority_queue2();
	return 0;
}

像这个地方我们对于Date*这个类型

我们不可能去重载操作符

因为Date*是内置类型

但是我每次new的地址的大小是随机的

因此我们在这个地方要根据Date大小去建堆就只能自己写一个仿函数了