STL-函数对象

一、函数对象

（一）函数对象概念

概念：

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

本质：

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

（二）函数对象使用

特点：

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

#include<iostream>
using namespace std;
#include<string>
//函数对象（仿函数）
/*
1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
2.函数对象超出普通函数的概念，函数对象可以有自己的状态
3.函数对象可以作为参数传递
*/
class MyAdd{
    public:
    int operator ()(const int& a,const int& b)const{
        return a+b;
    }
};
class MyPrint{
    public:
    MyPrint(){
        this->count=0;
    
    }
    void operator () (const string& str)const{
        cout<<str<<endl;
        count++;
    }
    mutable int count; //记录内部自己的状态
};
void test01(){
    //1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
    MyAdd myAdd;
    cout<<myAdd(10,20)<<endl;
}

void test02(){
    //2.函数对象超出普通函数的概念，函数对象可以有自己的状态
    MyPrint myPrint;
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    MyPrint myPrint2;
    myPrint2("hello world");
    cout <<"Myprint调用的次数为："<<myPrint.count<<endl;
}
void doPrint(MyPrint &mp,string test){
    mp(test);
}
void test03(){
    //3.函数对象可以作为参数传递
    MyPrint myPrint;
    doPrint(myPrint,"HELLO C++");
}
int WinMain(){
    test01();
    test02();
    test03();
    system("pause");
    return 0; 
}

二、谓词

（一）谓词概念

概念：

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

（二）谓词示例

1.一元谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//仿函数 返回值类型是bool数据类型 称为谓词
//一元谓词
class GreaterFive
{
public:
    bool operator()(const int& x)const {
        return x>5;
    }
};
void test01(){
    vector<int> v;
    for(int i=0;i<10;i++){
        v.push_back(i);
    }
    //查找容器中有没有大于5的数字
    //GreaterFive() 匿名的函数对象
vector<int>::iterator it = find_if(v.begin(),v.end(),GreaterFive()); //用迭代器接受结果
    if(it!=v.end()){
        cout<<"找到大于5的数字"<<*it<<endl;}
    else{
        cout<<"没有找到大于5的数字"<<endl;
    }

}
int WinMain(){
    test01();
    system("pause");
    return 0;
}

2.二元谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//二元谓词
class MyCompare{
    public:
    bool operator()(const int& a,const int& b)const{
        return a>b;
    }
};

void test01(){
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    sort(v.begin(),v.end());
    for(vector<int>::iterator it=v.begin();it!=v.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;
    //使用函数对象 改变排序规则从大到小
    cout<<"---------------"<<endl;
    sort(v.begin(),v.end(),MyCompare());
    for(vector<int>::iterator it=v.begin();it!=v.end();it++){
        cout<<*it<<" ";
    }
}


int WinMain(){
    test01();
    system("pause");
    return 0;
}

三、内建函数对象

（一）内建函数对象意义

概念：

• STL内建了一些函数对象

分类：

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

用法：

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

（二）算数仿函数

功能描述：

• 实现四则运算
• 其中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>  //取反仿函数

#include <iostream>
using namespace std;
#include <functional>
//内建函数对象 算数仿函数
//negate 取反 一元仿函数
void test01(){
    negate<int> n;
    cout<<n(50)<<endl; //输出-50
}
//plus 二元仿函数 加法
void test02(){
    plus<int> p;
    cout<<p(10,20)<<endl; //输出30
}
int main(){
    test01();
    test02();
    system("pause");
    return 0;
}

（三）关系仿函数

功能描述：

• 实现关系对比

仿函数原型：

• 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>    //小于等于

#include<iostream>
using namespace std;
#include<functional>
#include<vector>
#include<algorithm>
//内建函数 关系仿函数
//大于 greater
void test01(){
    vector<int> v;
    v.push_back(10);
    v.push_back(60);
    v.push_back(30);
    v.push_back(20);
    v.push_back(50);
    //降序排序 内建对象
    sort(v.begin(),v.end(),greater<int>());
    for(vector<int>::iterator it =v.begin();it!=v.end();it++){
        cout << *it <<" ";
    }
    cout<<endl;
}

int main(){
    test01();
    system("pause");
    return 0;
}

（四）逻辑仿函数

功能描述：

• 实现逻辑运算

函数原型：

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

#include<iostream>
using namespace std;
#include<functional>
#include<vector>
#include<algorithm>
//内建函数 逻辑仿函数
//逻辑非 logical_not
void test01(){
    vector<bool> v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);
    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;
}

int main(){
    test01();
    system("pause");
    return 0;
}