STL函数对象

1.函数对象概念

概念;
重载函数调用操作符的类,其对象常称为函数对象
函数对象使用重载的（）时,行为类似函数调用,也叫仿函数

本质:
函数对象(仿函教)是一个类,不是一个函数

2.函数对象使用

特点:
函数对象在使用时，可以像普通函数那样调用,可以有参数，可以有返回值

函数对象超出普通函数的概念,函数对象可以有自己的状态
函数对象可以作为参数传递

//函数对象
//加法
class MyAdd {
public :
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }
};
//打印
class PintStr
{

public:

    PintStr() 
    {
        this->count = 0;
    }
    void operator()(string str) {
        cout << str << endl;
        this->count++;
    }

    int count; //内部自己的状态
};
//打印
void doPrint(PintStr& ps, string str) {
    ps(str);
}
void test098() 
{
    //1.函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl;

    //2.函数对象超出普通函数的概念, 函数对象可以有自己的状态
    PintStr  ps;
    ps("you are my hero");
    ps("this is ");
    cout << " PintStr 调用了" << ps.count << "次 \n";

    //3.函数对象可以作为参数传递
    doPrint(ps, "hello zhang");

}

3.谓词

概念:
返回bool类型的仿函教称为谓词
如果operator()接受一个参数。那么叫做一元谓词

如果operator()接受两个参数。那么叫做二元谓词

1.一元谓词

//一元谓词
class GeraterFive
{
public :
    bool operator()(int v1) {

        return v1 > 5;
    }
};
void test1235() {
    vector<int> v;
    for (int i = 0; i < 10; i++) {
        v.push_back(i);
    }
    //查找容器中，有没有大于5的数字
    // GeraterFive() 匿名函数对象 pre 表示想要一个谓词
    vector<int>::iterator it=find_if(v.begin(),v.end(), GeraterFive());
    if (it == v.end()) {
        cout << "未找到" << endl;
    }
    else {
        cout << "找到了" << *it<<endl;
    }
}

2.二元谓词

//二元谓词
//使用函数对象 改变算法排序规则
class Compare {
public:
    bool operator()(int v1,int v2) {
        return v1 > v2;
    }
};
void test56889() {
    vector<int> v;
    
    v.push_back(26);
    v.push_back(56);
    v.push_back(96);
    v.push_back(26);
    v.push_back(86);
    v.push_back(76);

    sort(v.begin(),v.end(), Compare());

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

4.内建函数对象

概念:
STL内建了一些函教对象

分类:
·算术仿函数

·关系仿函教

·逻辑仿函数

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

1.算术仿函数

功能描述;
实现四则运算
其中negate是一元运算,其他都是二元运算仿

函数原型:
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>     //取反仿函数

//negate 一元仿函数 取反仿函数
    negate<int> n;
    cout << n(5) << endl;;
    //plus 二元仿函数  加法
    plus<int>p;
    cout << p(10, 6) << endl;

2.关系仿函教

功能描述:
实现关系对比

仿函数原型:
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>            //小于等于

vector<int> v;

    v.push_back(26);
    v.push_back(56);
    v.push_back(96);
    v.push_back(26);
    v.push_back(86);
    v.push_back(76);

    
    //降序
    //greater<int>() 内建的仿函数
    sort(v.begin(), v.end(), greater<int>());

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;

3.逻辑仿函数

功能描述:
实现逻辑运算

函数原型:
template<class T>  bool  logical_and<T>  //逻辑与
template<class T>  bool  logical_or<T>       //逻辑或
template<class T>  bool   logical_not<T>     //逻辑非

//逻辑非 logic_not
    vector<bool> v;

    v.push_back(true);
    v.push_back(false);
    v.push_back(false);
    v.push_back(true);

    for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    //利用逻辑非，将容器v 搬运到 容器v2中,并执行取反操作
    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;