谓词、内建函数对象、函数对象适配器
一、谓词概念
谓词是指普通函数或重载的operator（）返回值是bool类型的函数对象（仿函数）。如果operator接收一个参数，那么叫做一元谓词，如果接收两个参数，那么叫做二元谓词，谓词可作为一个判断式。
二、内建函数对象
STL内建了一些函数对象，分为：算数类函数对象，关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能，使用内建函数对象，需要引入头文件#include<functional>。
6个算数类函数对象，除了negate是一元运算，其他都是二元运算。
6个关系运算类函数对象，每一种都是二元运算。
逻辑运算类仿函数，not为一元运算，其余为二元运算。
案例（以plus为例）：
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <functional> using namespace std; void test01() { //使用内建函数对象声明一个对象 plus<int> myplus; cout << myplus(10, 20) << endl;//30 //使用匿名临时对象 cout << plus<int>()(5, 6) << endl;//11 } int main(void) { test01(); return 0; }
三、函数对象适配器
函数对象适配器是完成一些配接工作，这些配接包括绑定（bind），否定（negate），以及一对一般函数或成员函数的修饰，使其成为函数对象，重点掌握函数对象适配器（红色字体）：
bind1st：将参数绑定为函数对象的第一个参数
bind2nd：将参数绑定为函数对象的第二个参数
not1：对一元函数对象取反
not2：对二元函数对象取反
ptr_fun：将普通函数修饰成函数对象
mem_fun：修饰成员函数
mem_fun_ref：修饰成员函数
1、绑定适配器：bind1st、bind2nd
bind1st和bind2nd函数把一个二元函数对象绑定成为一个一元函数对象。但是由于二元函数对象接受两个参数，在绑定成为一元函数对象时需要将原来两个参数中的一个绑定下来。也即通过绑定二元函数对象的一个参数使之成为一元函数对象的。bind1st是绑定第一个参数，bind2nd则是绑定第二个参数。
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <vector> #include <algorithm> #include <functional> using namespace std; struct MyPrint:public binary_function<int,int,void> { void operator()(int v, int val) const { cout << v + val << " "; cout << "v:" << v << " val:" << val << endl; } }; //仿函数适配器 bind1st bind2nd 绑定适配器 void test01() { vector<int> v; for (int i = 0;i < 10;i++) { v.push_back(i); } int addNum = 200; //绑定适配器 将一个二元函数对象转变成一元函数对象 for_each(v.begin(), v.end(), bind1st(MyPrint(), addNum)); /* 200 v:200 val:0 201 v:200 val:1 202 v:200 val:2 203 v:200 val:3 204 v:200 val:4 205 v:200 val:5 206 v:200 val:6 207 v:200 val:7 208 v:200 val:8 209 v:200 val:9 */ for_each(v.begin(), v.end(), bind2nd(MyPrint(), addNum)); /* 200 v:0 val:200 201 v:1 val:200 202 v:2 val:200 203 v:3 val:200 204 v:4 val:200 205 v:5 val:200 206 v:6 val:200 207 v:7 val:200 208 v:8 val:200 209 v:9 val:200 */ //由此可得bind1st与bind2nd的区别： //bind1st 将addNum绑定为函数对象的第一个参数； //bind2nd 将addNum绑定为函数对象的第二个参数 } int main(void) { test01(); return 0; }
2、取反适配器：not1和not2
not1是构造一个与谓词结果相反的一元函数对象，not2是构造一个与谓词结果相反的二元函数对象。
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <vector> #include <algorithm> #include <functional> using namespace std; struct MyCompare :public binary_function<int, int, bool> { //由大到小比较 bool operator()(int v1,int v2) const { return v1 > v2; } }; struct MyPrint02 { void operator()(int v) { cout << v << " "; } }; struct MyGreater5:public unary_function<int,bool> { //第一个大于5的数 bool operator()(int v) const { return v > 5; } }; //仿函数适配器 not1 not2 取反适配器 void test02() { vector<int> v; for (int i = 9;i > -1;i--) { v.push_back(i); } for_each(v.begin(), v.end(), MyPrint02()); cout << endl;//9 8 7 6 5 4 3 2 1 0 sort(v.begin(), v.end(), not2(MyCompare()));//由小到大排序 for_each(v.begin(), v.end(), MyPrint02());//0 1 2 3 4 5 6 7 8 9 cout << endl; //not1 not2 区别 //如果对一元谓词取反，用not1； //如果对二元谓词取反，用not2； vector<int>::iterator it = find_if(v.begin(), v.end(), not1(MyGreater5()));//第一个小于等于5的值 if (it == v.end()) { cout << "没有找到！" << endl; } else { cout << *it << endl;//0 } } int main(void) { test02(); return 0; }
3、函数对象适配器：ptr_fun
ptr_fun是将一个普通的函数适配成一个仿函数(functor)
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <vector> #include <algorithm> #include <functional> using namespace std; //仿函数适配器 ptr_fun void MyPrint03(int val1,int val2)//普通函数MyPrint03 { cout << val1 + val2 << " "; cout << "val1:" << val1 << " val2:" << val2 << endl; } void test03() { vector<int> v; for (int i = 0;i < 10;i++) { v.push_back(i); } //ptr_fun:把普通函数 转成 函数对象 for_each(v.begin(), v.end(), bind1st(ptr_fun(MyPrint03),10)); /* 10 val1:10 val2:0 11 val1:10 val2:1 12 val1:10 val2:2 13 val1:10 val2:3 14 val1:10 val2:4 15 val1:10 val2:5 16 val1:10 val2:6 17 val1:10 val2:7 18 val1:10 val2:8 19 val1:10 val2:9 */ } int main(void) { test03(); return 0; }
4、成员函数适配器：mem_fun、mem_fun_ref
mem_fun_ref的作用和用法跟mem_fun一样，唯一的不同就是：当容器中存放的是对象实体的时候用mem_fun_ref，当容器中存放的是对象的指针的时候用mem_fun。
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <vector> #include <algorithm> #include <functional> using namespace std; void test04() { //如果容器中存放的对象或者对象指针，for_each算法打印的时候，调用类自己提供的打印函数 vector<Person> v; Person p1(10, 20), p2(30, 40), p3(50, 60); v.push_back(p1); v.push_back(p2); v.push_back(p3); //mem_fun_ref 格式：&类名::函数名 for_each(v.begin(), v.end(), mem_fun_ref(&Person::show)); /* age:10 id:20 age:30 id:40 age:50 id:60 */ cout << "-------------" << endl; vector<Person*> v1; v1.push_back(&p1); v1.push_back(&p2); v1.push_back(&p3); for_each(v1.begin(), v1.end(), mem_fun(&Person::show)); /* age:10 id:20 age:30 id:40 age:50 id:60 */ //mem_fun_ref mem_fun 区别？ //如果存放的是对象指针 使用mem_fun //如果存放的是对象 使用mem_fun_ref } int main(void) { test04(); return 0; }
