这三种模式, 感觉非常类似, 都是把核心类包一层, 在外部做一些额外的事情, 我还没发现他们之间具体的区别, 有想法的同学, 可以评论或者私聊我

适配器模式

简介: 就是在目标类外面包一层, 用以适配其他的模块,兼容整个程序框架
举个例子: 比如运动员, 中国运动员参加法国奥运会, 国外运动员交流的时候, 需要翻译,
翻译的角色就可以用适配器来表示
代码

class Player
{
public:
	string name;
	Player(string _n) : name(_n) {};
	virtual void listen(string s) = 0 {};
	virtual string speak() = 0 {};
};


class ForeignPlayer : public Player
{
public:
	ForeignPlayer(string _n) : Player(_n) {};
	void listen(string s) override
	{
		cout << "I'm " << name << ", I listen : " << s << endl;
	}
	string speak()override
	{
		cout << "I'm " << name << ", I speak hello " << endl;
		return "hello";
	}
};


class ChinesePlayer : public Player
{
public:
	ChinesePlayer(string _n) : Player(_n) {};
	void listen(string s)override
	{
		cout << "我是" << name << ", 我听到了 : " << s << endl;
	}
	string speak()override
	{
		cout << "我是" << name << ", 我说 : 你好" << endl;
		return "你好";
	}
};


class ChinesePlayerTranslator : public Player
{
private:
	ChinesePlayer* cp;
public:
	ChinesePlayerTranslator(string _n, ChinesePlayer* _cp) : Player(_n), cp(_cp) {};
	string c2e(string s)
	{
		cout << "我是" << name << ", " << s << " 翻译为 " << "hello" << endl;
		return "hello";
	}
	string e2c(string s)
	{
		cout << "我是" << name << ", " << s << " 翻译为 " << "你好" << endl;
		return "你好";
	}
	void listen(string s)override
	{
		cp->listen(e2c(s));
	}
	string speak()override
	{
		string s = cp->speak();
		return c2e(s);
	}
};


int main()
{
	ForeignPlayer* fp = new ForeignPlayer("roland");
	ChinesePlayer* cp = new ChinesePlayer("王富贵");
	ChinesePlayerTranslator* cpt = new ChinesePlayerTranslator("小翻译", cp);

	cpt->listen(fp->speak());
	fp->listen(cpt->speak());

	return 0;
}

执行结果

修饰器模式

简介: 当添加的功能不是类的核心功能时, 或者只有某些特殊情况下才会走的逻辑, 直接添加到类中就不太好, 放到单独的修饰类中就很好
举个例子: 比如我们设计了一个人类, 然后我们用衣服和裤子来修饰他, 那么我们这三个类都继承同一个父类, 然后外界操作人的实例的时候, 就只需要获取衣服或者裤子的实例就行了, 因为他们内部不仅包含了人的实例, 还有其他的一些修饰特性.
代码

class Person
{
public:
	string name;
	Person(string _n) : name(_n) {};
	Person() {};
	virtual void show()
	{
		cout << "my name is " << name << endl;
	}
};


class Costume : public Person
{
public:
	Person* p;
	void decorate(Person* _p) { p = _p; };
	virtual void show() {};
};


class Tshirt : public Costume
{
public:
	void show() override
	{
		cout << "this is my Tshirt" << endl;
		p->show();
	}
};


class Trousers : public Costume
{
public:
	void show() override
	{
		cout << "this is my torusers" << endl;
		p->show();
	}
};


int main()
{
	Person* p = new Person("william");
	Tshirt* t1 = new Tshirt();
	Trousers* t2 = new Trousers();
	t2->decorate(t1);
	t1->decorate(p);
	t2->show();
	return 0;
}

执行结果

代理模式

简介: 不好说, 感觉和修饰器模式 与 适配器模式差不多, 都是包一层
代码

class CoreNet
{
public:
	void request()
	{
		cout << "this is core request" << endl;
	}
};


class NetProxy
{
public:
	CoreNet* cn;
	NetProxy()
	{
		cn = new CoreNet();
	}
	void request()
	{
		cout << "do some proxy things" << endl;
		cn->request();
	}
};


int main()
{
	NetProxy* np = new NetProxy();
	np->request();
	return 0;
}

执行结果