STL之函数对象适配器

1.函数适配器

现在我有这个需求:在遍历容器的时候，我希望将容器中的值全部加上100之后显示出来，怎么做？
在不需要加100的时候，只打印，很好实现：

class MyPrint{
public:
	void operator()(int v)
{
		cout <<v << endl;	
	}
};
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(), MyPrint());
}

当我们不使用内建函数和lambda表达式和全局函数的时候，也就是使用仿函数，实现容器中值全部+100，那么我们只需要三步：

1. 第一步 绑定 数据 bind2nd
2. 继承类 binary_function<参数类型1，参数类型2，返回值类型>
3. 加const修饰 operator()

class MyPrint :public binary_function<int,int,void>{//参数类型1，参数类型2，返回值类型
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将二元函数对象转为一元函数对象

2. 取反适配器

//一元取反适配器 not1
//继承类 unary_function<参数类型1，返回值类型>
//加const修饰 operator()
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(), [](int n){return n>5;});
 	//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迭代器，也就是0的迭代器
	//自定义输入
	//vector<int>::iterator it = find_if(v.begin(), v.end(), not1 ( bind2nd(greater<int>(),5)));//绑定内建函数greater<int>()和5之后应用取反适配器
	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 对二元函数对象取反

3. 函数指针适配器

函数指针适配器可以把一个普通的函数指针适配成函数对象（仿函数），省去了写类的繁琐。

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));
}

4. 成员函数适配器

把成员函数适配成全局函数

//4、成员函数适配器
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);
	//利用 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));
// 	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));
}

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