函数对象（仿函数）

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

函数对象特点

//函数对象是重载了函数调用符号的类
class MyPrint
{
    
public:
	MyPrint()
	{
    
		m_Num = 0;
	}
	int m_Num;

public:
	void operator() (int num)
	{
    
		cout << num << endl;
		m_Num++;
	}
};

//函数对象
//重载了()操作符的类实例化的对象，可以像普通函数那样调用,可以有参数 ，可以有返回值
void test01()
{
    
	MyPrint myPrint;
	myPrint(20);

}
// 函数对象超出了普通函数的概念，可以保存函数的调用状态
void test02()
{
    
	MyPrint myPrint;
	myPrint(20);
	myPrint(20);
	myPrint(20);
	cout << myPrint.m_Num << endl;
}

void doBusiness(MyPrint print,int num)
{
    
	print(num);
}

//函数对象作为参数
void test03()
{
    
	//参数1：匿名函数对象
	doBusiness(MyPrint(),30);//Myprint()匿名对象
}

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

谓词

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

class GreaterThenFive
{
    
public:
	bool operator()(int num)//一元谓词
	{
    
		return num > 5;
	}

};
//一元谓词
void test01()
{
    
	vector<int> v;
	for (int i = 0; i < 10;i ++)
	{
    
		v.push_back(i);
	}
	
	 vector<int>::iterator it =  find_if(v.begin(), v.end(), GreaterThenFive());//第三个参数是函数对象
	 if (it == v.end())
	 {
    
		 cout << "没有找到" << endl;
	 }
	 else
	 {
    
		 cout << "找到了: " << *it << endl;
	 }
}

//二元谓词
class MyCompare
{
    
public:
	bool operator()(int num1, int num2)//二元谓词
	{
    
		return num1 > num2;
	}
};

void test02()
{
    
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(90);
	v.push_back(60);

	//默认从小到大
	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 << " ";
	}
	cout << endl;
}
  //匿名函数  lambdab表达式写法[](参数){函数体}
  for_each(v.begin(),v.end(),[](int val){
    cout<<val<<"";});

内建函数

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

• 6个算数类函数对象,除了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>//取反仿函数

• 6个关系运算类函数对象,每一种都是二元运算。

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

• 逻辑运算类运算函数,not为一元运算，其余为二元运算。

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

内建函数对象举例:

//取反仿函数
void test01()
{
    
	negate<int> n;
	cout << n(50) << endl;
}

//加法仿函数
void test02()
{
    
	plus<int> p;
	cout << p(10, 20) << endl;
}

//大于仿函数
void test03()
{
    
	vector<int> v;
	srand((unsigned int)time(NULL));
	for (int i = 0; i < 10; i++){
    
		v.push_back(rand() % 100);
	}

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
    
		cout << *it << " ";
	}
	cout << endl;
	sort(v.begin(), v.end(), greater<int>());//使用greater内建函数

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

}

适配器

函数适配器

1.给函数对象绑定参数
2.根据我们函数对象是一元函数对象 还是二元函数对象，使自己的函数对象继承于binary_function(二元) 或者 unary_function（一元）
3.加const修饰operator()函数

总结： bind1st和bind2nd区别?

• bind1st ： 将参数绑定为函数对象的第一个参数
• bind2nd ： 将参数绑定为函数对象的第二个参数
• bind1st bind2nd将二元函数对象转为一元函数对象

//函数适配器bind1st bind2nd
//现在我有这个需求 在遍历容器的时候，我希望将容器中的值全部加上100之后显示出来，怎么做？
//我们直接给函数对象绑定参数 编译阶段就会报错
//for_each(v.begin(), v.end(), bind2nd(myprint(),100));
//如果我们想使用绑定适配器,需要我们自己的函数对象继承binary_function 或者 unary_function
//根据我们函数对象是一元函数对象 还是二元函数对象
class MyPrint :public binary_function<int,int,void>//<参数类型，参数类型，返回值类型>
{
    
public:
	void operator()(int v1,int v2) const//指定为常函数，不允许修改值
	{
    
		cout << "v1 = : " << v1 << " v2 = :" <<v2  << " v1+v2 = :" << (v1 + v2) << endl;	
	}
};
//1、函数适配器
void test01()
{
    
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
    
		v.push_back(i);
	}
	cout << "请输入起始值：" << endl;
	int x;
	cin >> x;

	for_each(v.begin(), v.end(), bind1st(MyPrint(), x));
	//for_each(v.begin(), v.end(), bind2nd( MyPrint(),x ));
}
//总结：  bind1st和bind2nd区别?
//bind1st ： 将参数绑定为函数对象的第一个参数
//bind2nd ： 将参数绑定为函数对象的第二个参数
//bind1st bind2nd将二元函数对象转为一元函数对象

取反适配器

not1 对一元函数对象取反
not2 对二元函数对象取反

class GreaterThenFive:public unary_function<int,bool>
{
    
public:
	bool operator ()(int v) const
	{
    
		return v > 5;
	}
};

//2、取反适配器
void test02()
{
    
    //一元取反
	vector <int> v;
	for (int i = 0; i < 10;i++)
	{
    
		v.push_back(i);
	}
	
// 	vector<int>::iterator it =  find_if(v.begin(), v.end(), GreaterThenFive()); //返回第一个大于5的迭代器
//	vector<int>::iterator it = find_if(v.begin(), v.end(),  not1(GreaterThenFive())); //返回第一个小于5迭代器，not1的1代表一元取反
	//自定义输入
	vector<int>::iterator it = find_if(v.begin(), v.end(), not1 ( bind2nd(greater<int>(),5)));//greater为内建函数
	if (it == v.end())
	{
    
		cout << "没找到" << endl;
	}
	else
	{
    
		cout << "找到" << *it << endl;
	}

	//排序  二元函数对象
	sort(v.begin(), v.end(), not2(less<int>()));
	for_each(v.begin(), v.end(), [](int val){
    cout << val << " "; });

}
//not1 对一元函数对象取反
//not2 对二元函数对象取反

函数指针适配器

ptr_fun( )把一个普通的函数指针适配成函数对象（仿函数）

void MyPrint03(int v,int v2)
{
    
	cout << v + v2<< " ";
}

//3、函数指针适配器   ptr_fun
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));
}

成员函数适配器

mem_fun_ref 将Person内部成员函数适配为函数对象（仿函数）

• 如果容器存放的是对象指针， 那么用mem_fun
• 如果容器中存放的是对象实体，那么用mem_fun_ref

class Person
{
    
public:
	Person(string name, int age)//有参构造
	{
    
		m_Name = name;
		m_Age = age;
	}

	//打印函数
	void ShowPerson(){
    
		cout << "成员函数:" << "Name:" << m_Name << " Age:" << m_Age << endl;
	}
	void Plus100()
	{
    
		m_Age += 100;
	}
public:
	string m_Name;
	int m_Age;
};

void MyPrint04(Person &p)///回调函数
{
    
	cout << "姓名：" <<  p.m_Name << " 年龄：" << p.m_Age << endl;

};

void test04()
{
    
    //容器中存放对象实体
	vector <Person>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//for_each(v.begin(), v.end(), MyPrint04);//myprint04回调函数
	//利用 mem_fun_ref 将Person内部成员函数适配
	for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson));
 	for_each(v.begin(), v.end(), mem_fun_ref(&Person::Plus100));
   //容器中存放的对象实体使用em_fun_ref 
}

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);
    //容器中存放的函数指针，使用em_fun
	for_each(v1.begin(), v1.end(), mem_fun(&Person::ShowPerson));
}

//如果容器存放的是对象指针，  那么用mem_fun
//如果容器中存放的是对象实体，那么用mem_fun_ref