一、函数对象
重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。
注意:
1.函数对象(仿函数)是一个类，不是一个函数。
2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。
一元仿函数是operator()中只需要一个参数，二元仿函数是operator()中有两个参数
函数对象和普通函数的区别:
- 函数对象有自己的状态
- 普通函数没有类型，函数对象有类型
- 函数对象比普通函数执行效率有可能更高（成员函数自动申请为内联函数）
函数对象(仿函数)可以作为算法的策略
函数对象的作用主要是什么？STL提供的算法往往都有两个版本，其中一个版本表现出最常用的某种运算，另一版本则允许用户通过template参数的形式来指定所要采取的策略。
struct MyPrint
{
void operator()(int val) {
cout << val << endl;
}
};
void test01() {
MyPrint pr;
pr(10); // 重载了()操作符的类实例化的对象，可以像普通函数那样调用,可以有参数 ，可以有返回值
}
struct MyMul
{
int operator()(int val1, int val2) {
return val1*val2;
}
};
void test02() {
MyMul mul;
cout << mul(10,20) << endl;
}
//函数对象超出了普通函数的概念，可以保存函数的调用状态
class HePrint {
public:
HePrint() {
mCount = 0;
}
void operator()(int val) {
cout << val << endl;
mCount ++;
}
public:
int mCount;
};
void test03() {
HePrint he;
he(7);
he(8);
he(9);
cout << he.mCount << endl;
}
//函数对象可以做参数和返回值
struct outPrint
{
void operator()(int val) {
cout << val << endl;
}
};
void doBussiness(outPrint p) {
p(100);
}
void test04() {
doBussiness(outPrint()); // 函数对象做参数
}
// 函数对象可以作为算法的策略
struct MyAdd
{
MyAdd() {
sum = 0;
}
int operator()(int val) {
sum += val;
return sum;
}
int sum;
};
struct PrintVec
{
void operator()(int val) {
cout << val << endl;
}
};
void test05() {
vector<int> vec;
vec.push_back(30);
vec.push_back(10);
vec.push_back(20);
sort(vec.begin(), vec.end()); // less<int>()
for_each(vec.begin(),vec.end(),PrintVec());
sort(vec.begin(), vec.end(), greater<int>());
for_each(vec.begin(),vec.end(),PrintVec());
MyAdd myadd = for_each(vec.begin(),vec.end(),MyAdd());
cout << myadd.sum << endl;
}
struct myfun1
{
bool operator()(int key1, int key2)
{
return key1 > key2;
}
};
void test08()
{
set<int,greater<int> > myset;
myset.insert(8);
myset.insert(3);
myset.insert(5);
myset.insert(9);
myset.insert(7);
for_each(myset.begin(),myset.end(),myPrint);
cout << endl;
set<int,myfun1 > myset2;
myset2.insert(8);
myset2.insert(3);
myset2.insert(5);
myset2.insert(9);
myset2.insert(7);
for_each(myset2.begin(),myset2.end(),myPrint);
cout << endl;
}
二、谓词
谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。
// 一元谓词
struct GreaterThanFive
{
bool operator()(int v){
return v>5;
}
};
void test09() {
vector<int> v;
for(int i=0; i<10; i++) {
v.push_back(i);
}
vector<int>::iterator ret = find_if(v.begin(), v.end(), GreaterThanFive());
if(ret == v.end()){
cout <<"没有找到!"<< endl;
}
else{
cout <<"找到:"<<*ret << endl;
}
}
// 二元谓词
struct MyCompare{
bool operator()(int v1,int v2){
return v1 > v2;
}
};
void test10() {
vector<int> v;
v.push_back(8);
v.push_back(1);
v.push_back(3);
v.push_back(9);
v.push_back(5);
sort(v.begin(),v.end(),MyCompare());
for_each(v.begin(),v.end(),myPrint);
cout << endl;
}
三、 内建函数对象
STL内建了一些函数对象。分为:算数类函数对象,关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象，需要引入头文件 #include<functional>。
6个算数类函数对象,除了negate是一元运算，其他都是二元运算
template<classT>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>//取反仿函数
6个关系运算类函数对象,每一种都是二元运算
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>//小于等于
逻辑运算类运算函数,not为一元运算，其余为二元运算
template<class T>bool logical_and<T>//逻辑与
template<class T>bool logical_or<T>//逻辑或
template<class T>bool logical_not<T>//逻辑非
void test07() {
plus<int> myplus;
cout << myplus(10,20) << endl;
}
