C++进阶-STL 函数对象的介绍

函数对象

函数对象概念

• 重载函数调用操作符的类，其对象常称为函数对象
• 函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：函数对象（仿函数）是一个类，不是一个函数

函数对象的使用

特点：

• 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
• 函数对象超出普通函数的概念，函数对象可以有自己的状态
• 函数对象可以作为参数传递

函数对象可以像普通函数一样调用

#include <iostream>
#include <string>
#include <map>
using namespace std;

class MyClass
{
public:
	int operator()(int i, int j) const
	{
		return i + j;
	}
};

int main()
{
	MyClass cl;
	//函数对象可以作为普通函数调用
	std::cout << cl(10, 23) << std::endl;
}

函数对象可以有自己的状态值

#include <iostream>
#include <string>
#include <map>
using namespace std;

class MyClass
{
private:
	mutable	int count;
public:
	MyClass()
	{
		this->count = 0;
	}
	int operator()(int i, int j) const
	{
		//函数对象可以有自己的状态值
		this->count = this->count + 1;
		return i + j;
	}
};

int main()
{
	MyClass cl;
	//函数对象可以作为普通函数调用
	std::cout << cl(10, 23) << std::endl;
	cl(10, 23);
	cl(10, 23);
}

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

谓词

• 返回bool类型的仿函数称为谓词
• 如果operator() 接受一个参数，那么叫做一元谓词
• 如果operator()接受两个参数，那么叫做二元谓词

一元谓词

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

class MyClass
{
public:
	bool operator()(int i) const
	{
		return i > 5;
	}
};

int main()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中有没有大于5的数字
	vector<int>::iterator it = find_if(v.begin(), v.end(), MyClass());  //MyClass() 匿名函数对象
	if (it == v.end())
	{
		std::cout << "没有找到！" << std::endl;
	}
	else 
	{
		std::cout << "找到结果了！" << std::endl;
	}
}

二元谓词

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

class MyClass
{
public:
	bool operator()(int i, int j) const
	{
		return i > j;
	}
};

int main()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	sort(v.begin(), v.end(), MyClass());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		std::cout << *it << " ";
	}
	std::cout << std::endl;
}

内建函数对象

STL中内建了一些函数对象，其分为算数仿函数、关系仿函数、逻辑仿函数，这些仿函数所产生的对象，用法和一般函数完全相同，使用内建函数对象，需要引入头文件 #include <functional>

内建函数对象-算术仿函数

作用：实现四则运算，其中negate是一元运算，其他都是二元运算

• template<class T> T plus<T> 加法仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	plus<int> pl;
	std::cout << pl(30, 40) << std::endl;
}

• template<class T> T minus<T> 减法仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	minus<int> pl;
	std::cout << pl(30, 40) << std::endl;
}

• template<class T> T multiplies<T> 乘法仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	multiplies<int> pl;
	std::cout << pl(30, 40) << std::endl;
}

• template<class T> T divides<T> 除法仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	divides<int> pl;
	std::cout << pl(30, 40) << std::endl;
}

• template<class T> T modulus<T> 取模仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	modulus<int> pl;
	std::cout << pl(30, 40) << std::endl;
}

• template<class T> T negate<T> 取反仿函数

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	negate<int> ne;
	std::cout << ne(30) <<std::endl;
}

内建函数对象-关系仿函数

• template<class T> bool equal_to<T> 等于
• template<class T> bool not_equal<T> 不等于
• template<class T> bool greater_equal<T> 大于等于
• template<class T> bool less<T> 小于
• template<class T> bool less_equal<T> 小于等于
• template<class T> bool greater<T> 大于

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

int main()
{
	vector<int> v;
	v.push_back(12);
	v.push_back(13);
	v.push_back(14);
	v.push_back(15);
	sort(v.begin(), v.end(), greater<int>());
}

内建函数对象-逻辑仿函数

• template<class T> bool logical_and<T> 逻辑与
• template<class T> bool logical_and<T> 逻辑或
• template<class T> bool logical_and<T> 逻辑非