C++函数对象（仿函数）

函数对象

重载函数调用操作符的类，其对象常称为函数对象

函数对象使用重载的()时，行为类似函数调用，也称为仿函数

函数对象（仿函数）是一个类，不是一个函数。

函数对象的使用特点

函数对象可以向普通参数一样调用，可以有参数、返回值

函数对象超出普通函数的概念，函数对象可以有自己的状态

函数对象可以作为参数传递

//函数对象可以向普通参数一样调用，可以有参数、返回值
class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};
 
//函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint
{
public:
	MyPrint()
	{
		this->count = 0;
	}
 
	void operator()(string test)
	{
		cout << test << endl;
		this->count++; //统计使用次数
	}
 
	int count; //内部自己状态
};
 
//函数对象可以作为参数传递
void do_print(MyPrint &mp, string test)
{
	mp(test);
}
 
void test()
{
	MyAdd myadd;
	cout << myadd(10, 10) << endl; //20
 
	MyPrint myprint;
	myprint("hello world");
	myprint("hello world");
	myprint("hello world");
	myprint("hello world");
	cout << "myprint调用次数" << myprint.count << endl;//4
 
	MyPrint myprint2;
	do_print(myprint, "hello     world");
}

谓词

返回bool类型的仿函数

如果operator()接受一个参数，称一元谓词

如果operator()接受两个参数，称二元谓词

//一元谓词
class GreatFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
 
//二元谓词
class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};
 
void test()
{
	cout << "一元谓词" << endl;
	vector<int>v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
 
	//查找容器中大于5的数字
	//GreatFive() 匿名函数对象
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreatFive()); //第三个参数为谓词
	if (it == v.end()) {
		cout << "未找到" << endl;
	}
	else {
		cout << "找到大于5为：" << *it << endl;//6
	}
 
	cout << "二元谓词" << endl;
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

内建函数对象

需要引入头文件#include <functional>

算数仿函数

实现四则运算

negate是一元运算，其他都是二元运算

仿函数原型：

template<class T>T plus<T>                加法

template<class T>T minus<T>             减法

template<class T>T multiplies<T>       乘法

template<class T>T devides<T>            除法

template<class T>T modules<T>          取模

template<class T>T negate<T>             取反

#include <functional>
void test()
{
	//加法
	plus<int>p;
	cout << p(10, 10) << endl; //20
	
	//取反
	negate<int>n;
	cout << n(10) << endl; //-10
}

关系仿函数

仿函数原型：

template<class T> bool equal_to<T>             等于

template<class T> bool not_equal<T>            不等于

template<class T> bool greater<T>                  大于（常用）

template<class T> bool greatre_equal<T>        大于等于

template<class T> bool less<T>                          小于

template<class T> bool less_equal<T>              小于等于

class MyCompare
{
public:
	bool operator()(int v1, int v2)
	{
		return v1 > v2;
	}
};
 
void test()
{
	vector<int>v;
 
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
 
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl; //10 20 30 40 
 
	//降序
	//sort(v.begin(), v.end(), MyCompare());
	//greater<int>()内建函数对象
	sort(v.begin(), v.end(), greater<int>());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl; //40 30 20 10
}

逻辑仿函数

仿函数原型：

template<class T> bool logical_and<T>    逻辑与

template<class T> bool logical_or<T>       逻辑或

template<class T> bool logical_not<T>      逻辑非

void test()
{
	vector<bool>v;
 
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
 
	for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl; //1 0 1 0
 
	//逻辑非
	vector<bool>v2;
	v2.resize(v.size());//先开辟空间
 
	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl; //0 1 0 1
}