函数对象基本概念

概念：

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

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

函数对象的使用

特点：

  • 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
  • 函数对象超出普通函数的概念，函数对象可以有自己的状态
  • 函数对象可以作为参数传递
#include<iostream>
#include<string>
using namespace std;
class Myadd {
public:
    int operator()(int a, int b)
    {
        return a + b;
    }
};
class Myprint {
public:
    int count;
    Myprint() {
        count = 0;
    }
    void operator()(string s)
    {
        count++;
        cout << s << endl;
    }
};
void test1()
{
    Myadd ma;
    int c = ma(10, 20);
    cout << c << endl;
}
void test2()
{
    Myprint mp;
    mp("hello,world");
    mp("hello,world");
    mp("hello,world");
    cout << "Myprint调用的次数为：" << mp.count << endl;
}
void doprint(Myprint& mp, string s)
{
    mp(s);
}
void test3()
{
    Myprint mp;
    doprint(mp, "hello,world");
}
int main()
{
    //test1();
    //test2();
    test3();
}

仿函数写法非常灵活,可以作为参数进行传递。

谓词

概念：

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

一元谓词

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
class GreaterFive {
public:
    bool operator()(int val)
    {
        return val > 5;
    }
};
void test()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    //查找容器中大于5的数。
    auto it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end())
    {
        cout << "未找到" << endl;
    }
    else {
        cout << "找到了大于5的数，为：" << *it << endl;
    }
}
int main()
{
    test();
}

二元谓词

#include<iostream>
#include<ctime>
#include<vector>
#include<algorithm>
using namespace std;
class compare {
public:
    bool operator()(int a, int b)
    {
        return a > b;
    }
};
void test()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(rand() % 100);
    }
    sort(v.begin(), v.end());
    for (int i = 0; i < 10; i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    //使用函数对象，改变算法策略，变为排序规则从大到小
    sort(v.begin(), v.end(), compare());
    for (int i = 0; i < 10; i++)
    {
        cout << v[i] << " ";
    }
}
int main()
{
    srand((unsigned int)time(NULL));
    test();
}

内键函数对象

概念：STL内建了一些函数对象
分类：

  • 算术仿函数
  • 关系仿函数
  • 逻辑仿函数

用法：

  • 这些仿函数所产生的对象，用法和一般函数完全相同
  • 使用内建函数对象，需要引入头文件#include

算术仿函数

功能描述：

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

仿函数原型：

  • template T plus//加法仿函数
  • template T minus//减法仿函数
  • template T multiplies//乘法仿函数
  • template T divides//除法仿函数
  • template T modulus//取模仿函数
  • template T negate//取反仿函数
#include<iostream>
#include<functional>
using namespace std;
//negate 一元仿函数 取反。
void test1()
{
    negate<int>n;
    cout << n(50) << endl;;
}
//plus    二元仿函数 加法
void test2()
{
    plus<int>p;
    cout << p(10, 20) << endl;
}
int main()
{
    test1();
    test2();
}

关系仿函数

功能：实现关系对比
仿函数原型：

  • template bool equal_to//等于
  • template bool not_equal_to//不等于
  • template bool greater//大于
  • template bool greater_equal//大于等于
  • template bool less//小于
  • template bool less_equal//小于等于
#include<iostream>
#include<functional>
#include<vector>
#include<algorithm>
using namespace std;
//内建函数对象——关系仿函数
//大于greater
void test1()
{
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(rand() % 100);
        cout << v[i] << " ";
    }
    cout << endl;
    sort(v.begin(), v.end(), greater<int>());
    for (int i = 0; i < 10; i++)
    {
        cout << v[i] << " ";
    }
}
int main()
{
    test1();
}

逻辑仿函数

功能描述：函数原型：
函数原型：

  • template bool logical_and//逻辑与
  • template bool logical_or//逻辑或
  • template bool logical_not//逻辑非
#include<iostream>
#include<functional>
#include<vector>
#include<algorithm>
using namespace std;
//内建函数对象——逻辑仿函数
//逻辑非 logical_not
void test1()
{
    vector<bool>v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);
    for (int i = 0; i < 4; i++)
    {
        cout << v[i] << endl;
    }
    cout << endl;
    vector<bool>temp;
    temp.resize(v.size());
    transform(v.begin(), v.end(), temp.begin(), logical_not<bool>());
    for (int i = 0; i < 4; i++)
    {
        cout << temp[i] << endl;
    }
}
int main()
{
    test1();
}