C++ 仿函数

一、介绍

        C++STL中的仿函数，又被称为函数对象，其实就是：重载了()运算符的类。

因为在使用重载的operator()时，类似于函数调用，因此被称为仿函数。

        ※注意※：仿函数本质上是一个类，不是函数。

二、仿函数与函数的区别

        二者最主要的区别，就在于仿函数本质上是一个类，所以类的内部可以用自定义成员来记录更多的信息和状态。

三、仿函数的使用

        下面举一个简单的例子，让各位能直观地感受到仿函数的妙用。

//仿函数
class ShowHello {
private:
	int showCount;//用于记录show次数
public:
	ShowHello() {
		//初始0次show
		showCount = 0;
	}

	//重载()运算符
	void operator()() {
		cout << "Hello" << endl;
		showCount++;//每次使用，show次数+1
	}

	int getShowCount() {
		return showCount;
	}
};

//主函数
int main() {
	ShowHello showhello;

	showhello();
	showhello();
	showhello();
	showhello();

	cout << "showHello的次数为：" << showhello.getShowCount() << endl;

	return 0;
}

        上述例子中，我们可以通过类内部的showCount成员来统计所谓的函数调用次数，这是普通函数无法做到的。程序的执行结果如下所示：

四、内建仿函数

        C++ STL中有一些内部的仿函数，被称为内建仿函数。他们通常分为三类：算术仿函数、关系仿函数、逻辑仿函数。在使用时，需要包含头文件#include<functional>。

4.1 算术仿函数

        C++ STL 提供了一些简单的四则运算：

声明 (这里不用蓝色，而是用褐色，请各位记住：仿函数不是函数，是类！)	解释
template<class T> T plus<T>         (二元运算)	加法 仿函数
template<class T> T minus<T>         (二元运算)	减法 仿函数
template<class T> T multiplies<T>         (二元运算)	乘法 仿函数
template<class T> T divides<T>         (二元运算)	除法 仿函数
template<class T> T modulus<T>         (二元运算)	取余 仿函数
template<class T> T negate<T>         (一元运算)	取反 仿函数

//加法 仿函数
plus<int> add;
//666 + 222 = 888
cout << add(666, 222) << endl;//888

//减法 仿函数
minus<int> sub;
//666 - 222 = 444
cout << sub(666, 222) << endl;//444

//乘法 仿函数
multiplies<int> mul;
//222 * 2 = 444
cout << mul(222, 2) << endl;//444

//除法 仿函数
divides<int> div;
//666 / 222 = 3
cout << div(666, 222) << endl;//3

//取余 仿函数
modulus<int> mod;
//666 % 300 = 66
cout << mod(666, 300) << endl;//66

//取反 仿函数
negate<int> neg;
//-50 -> 50
cout << neg(-50) << endl;//50

4.2 关系仿函数

        C++ STL 提供了一些表示二者大小关系的仿函数：

声明 (这里不用蓝色，而是用褐色，请各位记住：仿函数不是函数，是类！)	解释
template<class T> bool equal_to<T>         (二元运算)	等于 仿函数
template<class T> bool not_equal_to<T>         (二元运算)	不等于 仿函数
template<class T> bool greater<T>         (二元运算)	大于 仿函数
template<class T> bool greater_equal<T>         (二元运算)	大于等于 仿函数
template<class T> bool less<T>          (二元运算)	小于 仿函数
template<class T> bool less_equal<T>         (二元运算)	小于等于 仿函数

//等于 仿函数
equal_to<int> eql;
// 555 == 666 : false
cout << boolalpha << eql(555, 666) << endl;//false

//不等于 仿函数
not_equal_to<int> neql;
// 555 != 666 : true
cout << boolalpha << neql(555, 666) << endl;//true

//大于 仿函数
greater<int> grt;
// 666 > 666 : false
cout << boolalpha << grt(555, 666) << endl;//false

//大于等于 仿函数
greater_equal<int> grteql;
// 666 >= 666 : true
cout << boolalpha << grteql(666, 666) << endl;//true

//小于 仿函数
less<int> ls;
// 555 < 666 : true
cout << boolalpha << ls(555, 666) << endl;//true

//小于等于 仿函数
less_equal<int> lseql;
// 666 <= 666 : true
cout << boolalpha << lseql(666, 666) << endl;//true

4.3 逻辑仿函数

        C++ STL提供了一些逻辑运算的仿函数：

声明 (这里不用蓝色，而是用褐色，请各位记住：仿函数不是函数，是类！)	解释
template<class T> bool logical_and<T>         (二元运算)	逻辑与 仿函数
template<class T> bool logical_or<T>         (二元运算)	逻辑或 仿函数
template<class T> bool logical_not<T>         (一元运算)	逻辑非 仿函数

//逻辑与
logical_and<int> land;
// 0 && 6 = false
cout << boolalpha << land(0, 6) << endl;//false

//逻辑或
logical_or<int> lor;
// 0 || 6 = true
cout << boolalpha << lor(0, 6) << endl;//true

        这里我们用逻辑非来解释一下，平时使用内建仿函数的方便之处：

假设我们目前的需求是将向量v0中的全部bool元素取反，再存入v1中：

vector<bool> v0;
vector<bool> v1;

v0.push_back(true);
v0.push_back(false);
v0.push_back(true);
v0.push_back(false);

//v0 = true false true false
cout << "v0 : [";
for (bool e : v0) {
	cout << boolalpha << e << " ";
}
cout << "]" << endl;

//设置v1的大小
v1.resize(v0.size());
//设置将v0的元素，取反后装入v1
transform(v0.begin(), v0.end(), v1.begin(), logical_not<bool>());

//v1 = false true false true
cout << "v1 : [";
for (bool e : v1) {
	cout << boolalpha << e << " ";
}
cout << "]" << endl;

        注意：如果要使用transform函数，需要#include<algorithm>。程序运行结果如下：