Design Pattern Adaptor 适配器设计模式

适配器设计模式是为了要使用一个旧的接口，或许这个接口非常难用，或许是和新的更新的接口不兼容，所以须要设计一个适配器类，然后就能够让新旧的接口都统一。

就是这种一个图：

比方我们有这种一个旧的类：

class OldName
{
public:
	virtual void setName(string n) = 0;
	virtual string getName() = 0;
};

class OldNameMetheds : public OldName
{
	string name;
public:
	OldNameMetheds(string n = "") : name(n)
	{
	}

	void setName(string n)
	{
		name = n;
	}

	string getName()
	{
		return name;
	}
};

这样我们仅仅能设计一个字符串的名字。可是如今我们有一个新的类：

//base class
class NewName
{
public:
	virtual void setFirstName(string first) = 0;
	virtual void setLastName(string last) = 0;
	virtual string getFirstName() = 0;
	virtual string getLastName() = 0;
};

class NewNameMethod : public NewName
{
protected:
	string first_name;
	string last_name;
public:
	NewNameMethod(string first = "", string last = "") : first_name(first), 
		last_name(last)
	{
	}

	void setFirstName(string first)
	{
		first_name = first;
	}

	void setLastName(string last)
	{
		last_name = last;
	}

	string getFirstName()
	{
		return first_name;
	}

	string getLastName()
	{
		return last_name;
	}
};

旧类和新类就不兼容了。故此须要一个Adaptor接口类：

//The real adaptor class
class Old2NewNameAdaptor : public NewNameMethod
{
	OldName *old;
public:
	Old2NewNameAdaptor(OldName *o) : old(o)
	{
		string name = old->getName();
		unsigned i = 0;
		for (; i < name.size() && name[i] != ' '; i++)
		{
			first_name.push_back(name[i]);
		}
		for (i++; i < name.size(); i++) last_name.push_back(name[i]);
	}
};

能够看到。该类继承了新类，而且自己主动处理了oldname，把oldname的内容转存进newname中了，中间就是多了一个自己主动转换的功能，并没有太多奇妙的东西。可是对于用户来说就方便非常多啦。

然后能够这样使用：

void Adaptor_Run()
{
	OldName *oldname = &OldNameMetheds();
	oldname->setName("Bill Gate");

	//小心这样写会有错误：原来的名字就会变成空了。没保留NewName *old2new = &Old2NewNameAdaptor(oldname);原因：应该是由于这个是暂时变量。指针指向一个空的暂时变量。那么是没有数据的！

	Old2NewNameAdaptor o2n(oldname);

	NewName *old2new = &o2n;//这样写。结果正确！

	cout<<"The first name is: "<<old2new->getFirstName()<<endl
		<<"The last name is : "<<old2new->getLastName()<<endl;
}

这里的old2new是一个新类，能够使用这个新类操作旧类的数据了。

最后执行：