37，内建函数对象

37.1内建函数对象意义

STL内建了一些函数对象

分类：

算数仿函数

关系仿函数

逻辑仿函数

用法：
这些仿函数所产生的对象，用法和一般函数完全相同

使用内建函数对象，需要引入头文件#include<functional>

37.2算数仿函数

功能描述:

实现四则运算

其中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>//内建函数对象头文件
//内建函数对象 算数仿函数
//begate 一元仿函数 取反仿函数
void test01()
{
	negate<int>n;
	cout << n(50) << endl;
}
//plus 二元仿函数 加法
void test02()
{
	plus<int>p;
	cout << p(10, 20) << endl;
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：使用内建函数对象时，需要引入头文件#include<functional>

37.3关系仿函数

功能描述：

实现关系对比

仿函数原理：
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 <vector>
#include <algorithm>
#include <functional>
class MyCompare
{
public:
	bool operator()(int& v1, int& v2)
	{
		return v1 > v2;
	}
};
void printV(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	printV(v);
	//降序
	//第一种
	sort(v.begin(), v.end(), MyCompare());
	printV(v);
	//第二种
	sort(v.begin(), v.end(), greater<int>());
	//greater<int>()通过内建的仿函数创建匿名对象（内建函数对象）
	//第一种不好改变类型，类型多时得创建好几个模板
	//第二种需要什么类型直接在<>中改就行了
	printV(v);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：关系仿函数中最常用的就是greater<>大于

37.4逻辑仿函数

功能描述：

实现逻辑运算

函数原型：

template<class T>bool logical_and<T>      //逻辑与

template<class T>bool logical_or<T>         //逻辑或

template<class T>bool logical_not<T>       //逻辑非

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
using namespace std;
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;
    //利用逻辑非 将容器搬运到容器v2中，并执行反操作
    vector<bool>v2;
    v2.resize(v.size());
    //目标容器必须提前开辟空间，否则会报错
    transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
    //transform算法:转换
    //原容器的begin()迭代器到原容器的end()迭代器区间，目标容器起始迭代器,逻辑仿函数
    for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
    {
         cout << *it << " ";
    }
    cout << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

总结：逻辑仿函数实际应用较少，了解即可