C++实现适配器模式（手动实现绑定功能）

首先要先理解什么是适配器模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用场景：

1、已经存在的类的接口不符合我们的需求；

2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；

3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。

说白了：其实就好比，你的苹果充电器是香港买的三孔插头，但是你现在在国内，只有二孔插座，那么适配器就是让你的三孔插头变成二孔插头，然后成功和二孔插座适配

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

class Person
{
public:
	Person(string name, int age) :name(name), age(age) {}
	string name;
	int age;

};
struct MyPrint
{
	void operator()(const Person p1)
	{
		cout << "name:" << p1.name << " age:" << p1.age  << endl;
	}
};

int main(void)
{
	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(),MyPrint());
	
	cout << endl;
	system("pause");
	return 0;
}

    以上的代码，如果要实现遍历vector容器中的所有Person，那么就可以使用for_each函数，传入容器的开始迭代器v.begin()和结束迭代器v.end()，以及函数指针或者是函数对象MyPrint(),这样，for_each就可以根据传进的对象进行遍历。

    这时候我们也可以看看for_each的底层实现：

圈住的First就是容器开始地址，Last就是结束地址，由于for_each是一个函数模板，所以能够根据你传进来的参数进行类型推到。

再到下面蓝色区域的时候，我们可以发现，for_each核心还是调用_Func(*_First);也就是说，它会根据你传进来的参数，调用它含有一个参数的回调函数。

那么，问题来了：

如果这时候我们的_Func在没有绑定参数的时候已经有两个参数，那我们应该怎样写才可以适配这个for_each接口呢？

假设负责输出的函数对象变成如下的时候，我们就不能直接调用for_each算法了，因为他只能调用含有一个参数的函数，但是这里面的括号运算符重载只重载了两个参数的函数，那么我们应该怎样将两个参数的函数变为一个参数的函数？

struct MyPrint
{
	void operator()(const Person p1, int val1) const
	{
		cout << "name:" << p1.name << " age:" << p1.age + val1 << endl;
	}
};

这就是我们的适配器模式了：

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;


class Person
{
public:
	Person(string name, int age) :name(name), age(age) {}
	string name;
	int age;

};
struct MyPrint:public binary_function<Person,int,void>
{
	void operator()(const Person p1, int val1) const
	{
		cout << "name:" << p1.name << " age:" << p1.age + val1 << endl;
	}
};

template<class _Fn2>
class MyBind2nd
{
public:
	MyBind2nd(typename _Fn2 Op, typename _Fn2::second_argument_type v)
	{
		this->Op = Op;
		this->_Value = v;
	}
	typename _Fn2::result_type operator()(typename _Fn2::first_argument_type val)
	{
		return this->Op(val, this->_Value);
	}
private:
	typename _Fn2 Op;
	typename _Fn2::second_argument_type _Value;
};


template<class _Fn2,class _Fy>
MyBind2nd<_Fn2> MyBinder(_Fn2  m, _Fy val)
{
	return MyBind2nd<_Fn2>(m, val);
}

int main(void)
{
	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(), MyBinder(MyPrint(),100));
	
	cout << endl;
	system("pause");
	return 0;
}

为什么要让 MyPrint 继承 binary_function ？

我们进去看看binary_function的实现

    意思就是说，只要MyPrint继承的这个类，那么里面存放了定义它重载了的括号运算符（不懂的话可以百度一下什么是括号运算符）的第一个参数，第二个参数和返回值的类型，这样我们就可以写出绑定起的类模板MyBind2nd和函数模板MyBinder，通过调用MyBinder函数构造一个MyBind2nd对象，并且里面存放了实例m以及绑定值val。然后for_each在调用的时候，就可以通过调用MyBinder这个适配器对象的括号运算符来调用原本函数的括号运算符，最终实现将两个参数变为一个参数

最终。。。说白了，实现的就是STL里面的bind2nd函数的功能，但是如果你懂了他底层的原理，那么绑定N个参数都可以写了。