C++之STL（三）

Love The Way You Lie 2022-01-06 07:19 247阅读 0赞

**目录**

1、函数对象（仿函数）

2、谓词

3、内建函数对象

4、适配器

--------------------

### 1、函数对象（仿函数） ###

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。

注意：

*  1.函数对象(仿函数)是一个类，不是一个函数。
 *  2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。

STL提供的算法往往都有两个版本，其中一个版本表现出最常用的某种运算，另一版本则允许用户通过template参数的形式来指定所要采取的策略。

*  重载() 所以函数的对象使用（）像函数调用
 *  是类 而不是普通的函数
 *  内部记录状态
 *  作为类型 与模板进行配合

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    using namespace std;
    
    class MyPrint
    {
    public:
    	void operator()(int num)
    	{
    		cout << "num  " << num << endl;
    		count++;
    	}
    	int count = 0;
    };
    
    void MyPrint2(int num)
    {
    	cout << "num  " << num << endl;
    }
    
    void test01()
    {
    	//MyPrint是一个类，而不是函数
    	MyPrint myPrint;
    	myPrint(111); //仿函数调用
    
    	//MyPrint2(111);
    
    	MyPrint()(1000);
    }
    
    //函数对象超出普通函数概念，内部可以保存状态
    void test02()
    {
    	MyPrint myPrint;
    	myPrint(111);
    	myPrint(111);
    	myPrint(111);
    	myPrint(111);
    
    	cout << "myPrint使用次数：" << myPrint.count << endl;
    }
    
    //函数对象作为参数
    void doPrint(MyPrint print, int num)
    {
    	print(num);
    }
    
    void test03()
    {
    	doPrint(MyPrint(), 20);
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	test03();
    	system("pause");
    	return 0;
    }

*  总结：
 *  1、函数对象通常不定义构造函数和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用的运行时问题。
 *  2、函数对象超出普通函数的概念，函数对象可以有自己的状态。
 *  3、函数对象可内联编译，性能好。用函数指针几乎不可能。
 *  4、模版函数对象使函数对象具有通用性，这也是它的优势之一。

### 2、谓词 ###

谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词，如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。

*  普通函数或者仿函数返回值 bool类型
 *  一元 一个参数 二元 两个参数
 *  一元 查找 大于20的数字 find\_if 返回迭代器
 *  二元 排序

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    
    class GreaterThan20
    {
    public:
    	bool operator()(int val)
    	{
    		return val > 20;
    	}
    };
    
    //一元谓词
    void test01()
    {
    	vector<int>v;
    	v.push_back(10);
    	v.push_back(20);
    	v.push_back(30);
    	v.push_back(40);
    	v.push_back(50);
    
    
    	//查找第一个大于20的数字
    	//第三个参数 函数对象 匿名对象
    	/*GreaterThan20 greaterThan;
    	find_if(v.begin(), v.end(), greaterThan);*/
    	vector<int>::iterator pos = find_if(v.begin(), v.end(), GreaterThan20());
    	if (pos != v.end())
    	{
    		cout << "找到大于20的数字为：" << *pos << endl;
    	}
    	else
    	{
    		cout << "未找到" << endl;
    	}
    
    }
    
    //二元谓词
    class MyCompare
    {
    public:
    	bool operator()(int v1, int v2)
    	{
    		return v1 > v2;
    	}
    };
    void test02()
    {
    	vector<int>v;
    	v.push_back(10);
    	v.push_back(20);
    	v.push_back(30);
    	v.push_back(40);
    	v.push_back(50);
    
    	sort(v.begin(), v.end(), MyCompare());
    
    	//匿名函数 lambda表达式 [](){};
    	for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
    }
    
    int main()
    {
    	//test01();
    	test02();
    	system("pause");
    	return 0;
    }

### 3、内建函数对象 ###

STL内建了一些函数对象。分为：算数类函数对象，关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象，需要引入头文件 \#include<functional>。

*  取反
 *  加法
 *  大于 greater

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    
    //内建函数对象头文件
    #include<functional>
    
    
    void test01()
    {
    	//template<class T> T negate<T>//取反仿函数
    	negate<int>n;
    	cout << n(10) << endl;
    
    	//template<class T> T plus<T>//加法仿函数
    	plus<int>p;
    	cout << p(1, 1) << endl;
    }
    
    //template<class T> bool greater<T>//大于
    void test02()
    {
    	vector<int>v;
    
    	v.push_back(10);
    	v.push_back(20);
    	v.push_back(30);
    	v.push_back(40);
    	v.push_back(50);
    
    	sort(v.begin(), v.end(), greater<int>());  //默认的是从小到大 less<int>()
    
    	for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
    }
    
    int main()
    {
    	//test01();
    
    	test02();
    	system("pause");
    	return 0;
    }

### 4、适配器 ###

*  函数适配器
 *  0~9加起始值 进行输出 用户提供起始值
 *  bind2nd 绑定 继承bianary\_function(参数类型1，参数类型2，返回值类型)
 *  const 修饰operator()
 *  取反适配器
 *  not1 一元 查找大于（小于）5
 *  not2 二元 对比 排序 默认less<int>() 从大到小 相当于 greater<int>()
 *  普通函数指针适配
 *  ptr\_fun
 *  成员函数适配
 *  如果容器存放的是对象指针， 那么用mem\_fun
 *  如果容器中存放的是对象实体，那么用mem\_fun\_ref

#define _CRT_SECURE_NO_WARNINGS
    #include<vector>
    #include<iostream>
    #include<algorithm>
    #include<functional>
    #include<string>
    using namespace std;
    
    class MyPrint:public binary_function<int, int, void>
    {
    public:
    	void operator()(int v, int start) const
    	{
    		cout << "v=" << v << " start=" << start << " v+start=" << v + start << endl;
    	}
    };
    
    void test01()
    {
    	vector<int>v;
    	for (int i = 0; i < 10; i++)
    	{
    		v.push_back(i);
    	}
    
    	cout << "请输入起始值：" << endl;
    	int num;
    	cin >> num;
    
    	//for_each(v.begin(), v.end(), bind2nd( MyPrint(),num));
    	for_each(v.begin(), v.end(), bind1st(MyPrint(), num));
    }
    
    //第一步  绑定数据  bind2nd
    //继承类  binary_function<参数类型1，参数类型2，返回值类型>
    //加const修饰operator()
    
    class GreaterThanFive: public unary_function<int,bool>
    {
    public:
    	bool operator()(int v) const
    	{
    		return v > 5;
    	}
    };
    
    //取反适配器
    void test02()
    {
    	//一元取反
    	vector<int> v;
    	for (int i = 0; i < 10; i++)
    	{
    		v.push_back(i);
    	}
    	//查找大于5的数字
    	//需求改为小于5的数字
    	//vector<int>::iterator pos = find_if(v.begin(), v.end(), not1(GreaterThanFive()));
    	vector<int>::iterator pos = find_if(v.begin(), v.end(), not1(bind2nd(greater<int>(),5)));
    	if (pos != v.end())
    	{
    		cout << "找到小于5的数字：" << *pos << endl;
    	}
    	else
    	{
    		cout << "未找到" << endl;
    	}
    }
    
    //一元取反适配器  not1
    //继承 unary_function <参数类型1，返回值类型>
    //const修饰
    
    void MyPrint03(int v, int start)
    {
    	cout << "v+start=" << v + start << 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(), bind2nd(ptr_fun(MyPrint03),100));
    }
    
    
    //成员函数适配器
    class Person
    {
    public:
    	Person(string name, int age)
    	{
    		this->m_Name = name;
    		this->m_Age = age;
    	}
    
    	void showPerson()
    	{
    		cout << "成员函数中姓名：" << m_Name << "  年龄：" <<  m_Age << endl;
    	}
    
    	void PlusAge()
    	{
    		this->m_Age = this->m_Age + 100;
    	}
    	string m_Name;
    	int m_Age;
    };
    
    void MyPrintPerson(Person &p)
    {
    	cout << "姓名：" << p.m_Name << "  年龄：" << p.m_Age << endl;
    }
    
    void test04()
    {
    	vector<Person>v;
    	Person p1("aaa", 10);
    	Person p2("bbb", 10);
    	Person p3("ccc", 10);
    	Person p4("ddd", 10);
    
    	v.push_back(p1);
    	v.push_back(p2);
    	v.push_back(p3);
    	v.push_back(p4);
    
    	//for_each(v.begin(), v.end(), MyPrintPerson);
    	//成员函数适配器
    	//mem_fun_ref
    	for_each(v.begin(), v.end(), mem_fun_ref(&Person::showPerson));
    	for_each(v.begin(), v.end(), mem_fun_ref(&Person::PlusAge));
    	for_each(v.begin(), v.end(), mem_fun_ref(&Person::showPerson));
    }
    
    void test05(){
    
    	vector<Person*> v1;
    	//创建数据
    	Person p1("aaa", 10);
    	Person p2("bbb", 20);
    	Person p3("ccc", 30);
    	Person p4("ddd", 40);
    
    	v1.push_back(&p1);
    	v1.push_back(&p2);
    	v1.push_back(&p3);
    	v1.push_back(&p4);
    
    	for_each(v1.begin(), v1.end(), mem_fun(&Person::showPerson));
    }
    
    
    int main()
    {
    	//test01();
    	//test02();
    	//test03();
    	//test04();
    	test05();
    	system("pause");
    	return 0;
    }