设计模式

优点：

（1）提供了对唯一实例的受控访问

（2）节约系统资源，只存在一个对象

缺点：

（1）扩展难，无抽象层

（2）单例类职责过重

适用场景：

（1）系统只需要一个实例对象，如任务管理器

（2）只允许使用一个公共访问节点，无法通过其它途径访问

让类与类进行组合

对其它对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，比如科学上网，而代理对象可以在客户端和目标对象之间起到中介的作用。玩家 *** 控游戏角色也相当于这个模式。

此处用系统的权限举例，用户开启系统时需要通过中间件系统验证类，通过后验证类才会调用系统的启动方法。

#include 
using namespace std;

//提供一种代理来控制对其他对象的访问
class AbstractCommonInterface{
public:
	virtual void run() = 0;
};

//系统
class MySystem : public AbstractCommonInterface{
public:
	virtual void run(){cout << "系统启动..." << endl;}
};

//必须有要权限验证，不是所有人都能来启动我的启动，提供用户名和密码
class MySystemProxy : public AbstractCommonInterface{
public:
	MySystemProxy(string username,string password){
		this->mUsername = username;
		this->mPassword = password;
		pSystem = new MySystem;
	}

	bool checkUsernameAndPassoword(){
		if (mUsername == "admin" && mPassword == "admin"){
			return true;
		}
		return false;
	}

	virtual void run(){
		if (checkUsernameAndPassoword()){
			cout << "用户名和密码正确，验证通过..." << endl;;
			this->pSystem->run();
		}
		else{
			cout << "用户名或者密码错误,权限不足..." << endl;
		}
	}
	~MySystemProxy(){
		if (pSystem != NULL){
			delete pSystem;
		}
	}
public:
	MySystem* pSystem;
	string mUsername;
	string mPassword;
};

void test01(){
	MySystemProxy* proxy = new MySystemProxy("admin","admin");
	proxy->run();
}

int main(void){
	test01();
	return 0;
}

优点：

（1）能够协同调用者和被调用者，在一定程度上降低了系统的耦合度

（2）增加更改代理类无需修改源代码，符合开闭原则，具有较好的可扩展性

缺点：

（1）代理实现可能较为复杂

（2）添加了中间件，运行速率可能有所下降

适用场景：

（1）为其他对象提供一种代理以控制对这个对象的访问

又称装饰器，包装模式，向一个现有的对象添加新的功能，同时又不改变其结构。

#include 
using namespace std;

//一般情况下 用继承实现类的功能拓展
//装饰模式  可以动态给一个类增加功能

//抽象英雄
class AbstractHero{
public:
	virtual void ShowStatus() = 0;
public:
	int mHp;//血量 
	int mAt;//攻击力 
};

//具体英雄
class HeroA : public AbstractHero{
public:
	HeroA(){
		mHp= 10 ;
		mAt= 1 ;
	}
	virtual void ShowStatus(){
		cout << "血量:" << mHp << endl;
		cout << "攻击:" << mAt << endl;
	}
};

//英雄穿上某个装饰物 那么他还是个英雄
class AbstractEquipment : public AbstractHero{
public:
	AbstractEquipment(AbstractHero* hero){
		this->pHero = hero;
	}
	virtual void ShowStatus(){}
public:
	AbstractHero* pHero;
};

//防具 
class Equipment1 : public AbstractEquipment{
public:
	Equipment1(AbstractHero* hero) :AbstractEquipment(hero){}
	//增加防御 
	void AddEquipment1(){
		cout << "英雄穿上防具之后..." << endl;
		this->mHp = this->pHero->mHp+100;
		this->mAt = this->pHero->mAt;
		delete this->pHero;
	}
	virtual void ShowStatus(){
		AddEquipment1(); //额外增加功能
		cout << "血量:" << mHp << endl;
		cout << "攻击:" << mAt << endl;
	}
};

//武器 
class Equipment2 : public AbstractEquipment{
public:
	Equipment2(AbstractHero* hero) :AbstractEquipment(hero){}
	//增加额外功能
	void AddEquipment2(){
		cout << "英雄装备武器之后..." << endl;
		this->mHp = this->pHero->mHp;
		this->mAt = this->pHero->mAt + 5;
		delete this->pHero;
	}
	virtual void ShowStatus(){
		AddEquipment2();
		cout << "血量:" << mHp << endl;
		cout << "攻击:" << mAt << endl;
	}
};

void test01(){
	AbstractHero* hero = new HeroA;
	hero->ShowStatus();
	cout << "---------------" << endl;
	//给英雄装备防具 
	hero = new Equipment1(hero);
	hero->ShowStatus();
	cout << "---------------" << endl;
	//给英雄装备武器
	hero = new Equipment2(hero);
	hero->ShowStatus();
}

int main(){
	test01();
	return 0;
}

优点：

（1）扩展一个对象的功能，装饰模式比继承更加灵活，不会导致类的个数急剧增加

（2）可以通过一种动态方式扩展一个对象而无需更改结构

（3）可以对对象进行多次装饰

（4）具体构建类（此处指英雄）和具体装饰类（这里指装备）可以独立变化，符合开闭原则

缺点：

（1）装饰模式会产生很多小对象，小对象若不即时释放会影响性能

适用场景：

（1）动态，透明的更改单个对象

（2）不能继承或不应该采用继承的场景可以用装饰模式

外观模式隐藏系统的复杂性，向客户端提供了一个可以访问系统的接口。相当于有个高层接口负责好了内部的业务逻辑，只需要调用此接口即可。

#include 
using namespace std;

//电视机
class Television{
public:
	void On(){cout << "电视机打开..." << endl;}
	void Off(){cout << "电视机关闭..." << endl;}
};

//灯
class Light{
public:
	void On(){cout << "灯打开..." << endl;}
	void Off(){cout << "灯关闭..." << endl;}
};
//音箱
class Audio{
public:
	void On(){cout << "音响打开..." << endl;}
	void Off(){cout << "音响关闭..." << endl;}
};

//麦克风
class Mircophone{
public:
	void On(){cout << "麦克风打开..." << endl;}
	void Off(){cout << "麦克风关闭..." << endl;}
};

//DVD播放器
class DVDPlayer{
public:
	void On(){cout << "DVD播放器打开..." << endl;}
	void Off(){cout << "DVD播放器关闭..." << endl;}
};

//游戏机
class Gamemachine{
public:
	void On(){cout << "游戏机打开..." << endl;}
	void Off(){cout << "游戏机关闭..." << endl;}
};


class KTVMode{
public:
	KTVMode(){
		pTv = new Television;
		pLight = new Light;
		pAudio = new Audio;
		pMicrophone = new Mircophone;
		pDvd = new DVDPlayer;
	}

	void OnKTV(){
		pTv->On();
		pLight->Off();
		pAudio->On();
		pMicrophone->On();
		pDvd->On();
	}

	void OffKTV(){
		pTv->Off();
		pLight->On();
		pAudio->Off();
		pMicrophone->Off();
		pDvd->Off();
	}

	~KTVMode(){
		delete pTv;
		delete pLight;
		delete pAudio;
		delete pMicrophone;
		delete pDvd;
	}
public:
	Television* pTv;
	Light* pLight;
	Audio* pAudio;
	Mircophone* pMicrophone;
	DVDPlayer* pDvd;
};
//无需自己设置各种设备，点击设置模式即可实现
void test01(){
	KTVMode* ktv = new KTVMode;
	ktv->OnKTV();
}

int main(void)
{
	test01();
	return 0;
}

优点：

（1）屏蔽了子系统组件，减少了客户端所需处理的对象数目，客户端代码简单

（2）实现了子系统与客户端之间的解耦合，减少了相互依赖

（3）一个子系统的修改对其它子系统没有影响，提高了安全性

缺点：

（1）增加新的子系统可能需要修改外观类的源代码，违背了开闭原则，维护难度大

（2）限制了客户端对子系统类的访问，减少了灵活性（客户端 *** 作空间少了，相对而言提高了安全性）

适用场景：

（1）复杂系统需要简单入口使用

（2）子系统相对独立

（3）预防低水平人员带来的风险（ *** 作空间少，仅需要调用个别接口）

作为两个不兼容的接口之间的桥梁。某函数不支持双参数，可以通过适配器实现一些奇奇怪怪的功能。比如一只老虎添加了适配器之后可以实现飞行功能。

#include 
#include
#include
using namespace std;

//适配器模式 就是将已经写好的接口，但是这个接口不符合需求
//将写好的接口转换成目标接口

struct MyPrint{
	void operator()(int v1,int v2){//运算符重载 
		cout << v1 + v2 << endl;
	}
};

class Target{
public:
	virtual void operator()(int v) = 0;
};

//写适配器
class Adapter : public Target{
public:
	Adapter(int param){
		this->param = param;
	}
	virtual void operator()(int v){
		print(v, param);
		//cout<<"aaa"< v; 
	for (int i = 0; i < 10;i++){
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), MyBind2nd(10));
	return 0;
}

优点：

（1）目标类和适配者类解耦，引入适配器类来重用现有的适配者类，无需修改原有结构

（2）增加了类的透明性和复用性

（3）灵活性和扩展性都很高，可以很方便的更换适配器，符合开闭原则

（4）可以让两个没有关联的类一起运行

缺点：

（1）适配器中置换适配者类的某些方法比较麻烦

（2）过多的使用适配器，系统会非常凌乱，比如明明调用A接口，却一起实现了B接口的功能，，出错的话维护难度大

适用场景：

（1）系统需要使用现有类，而接口不符合需要，甚至没有类的源代码

（2）将一些没有关联的类连接起来

（3）适配器并非设计时产生的，而是为了解决正在使用的项目所存在的问题

用来对类或对象怎么交互和分配职责进行描述

定义一个 *** 作中算法的框架，将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法结构的同时即可重定义该算法的某些特定步骤

#include
using namespace std;

class DrinkTemplate{
public:
	//煮水
	virtual void BoildWater() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加辅助料
	virtual void AddSomething() = 0;
	//模板方法
	void Make(){
		BoildWater();
		Brew();
		PourInCup();
		AddSomething();
	}
};

//冲泡咖啡
class Coffee : public DrinkTemplate{
public:
	virtual void BoildWater(){
		cout << "煮山泉水..." << endl;
	}
	//冲泡
	virtual void Brew(){
		cout << "冲泡咖啡..." << endl;
	}
	//倒入杯中
	virtual void PourInCup(){
		cout << "咖啡倒入杯中..." << endl;
	}
	//加辅助料
	virtual void AddSomething(){
		cout << "加糖，加牛奶,加点醋..." << endl;
	}
};

//冲泡茶水
class Tea : public DrinkTemplate{
public:
	virtual void BoildWater(){
		cout << "煮自来水..." << endl;
	}
	//冲泡
	virtual void Brew(){
		cout << "冲泡铁观音..." << endl;
	}
	//倒入杯中
	virtual void PourInCup(){
		cout << "茶水倒入杯中..." << endl;
	}
	//加辅助料
	virtual void AddSomething(){
		cout << "加糖..加柠檬...加生姜..." << endl;
	}
};

void test01(){
	Tea* tea = new Tea;
	tea->Make();
	cout << "-----------" << endl;
	Coffee* coffee = new Coffee;
	coffee->Make();
}

int main(){
	test01();
	return 0;
}

优点：

（1）封装不变部分，扩展可变部分

（2）代码复用程度高，便于维护

（3）行为由父类控制，子类实现，符合单一职责和开闭原则

缺点：

（1）每一个不同地实现都需要一个子类，类个数可能过多

适用场景：

（1）存在多个具有同样 *** 作步骤地应用场景，但具体 *** 作细节不同

将一个请求封装成一个对象，从而可以用不同地请求对客户进行参数化。命令模式可以将请求发送者和接收者解耦，两者之间没有直接引用关系，发送者只需要发生命令，而无需知道如何完成。这里用服务器和客户端比较好理解，可以理解为http协议请求，你只需要发送get请求给服务器，服务器会自动返回信息。

#include 
#include 
using namespace std;

//协议处理类
class HandleClientProtocol{
public:
	//处理增加金币
	void AddMoney(){cout << "给玩家增加金币！" << endl;}

	//处理玩家升级
	void addLevel(){cout << "给玩家升级!" << endl;}
};

//命令接口
class AbstractCommand{
public:
	virtual void handle() = 0; //处理客户端请求的接口
};

//处理增加金币请求
class AddMoneyCommand :public AbstractCommand{
public:
	AddMoneyCommand(HandleClientProtocol* protocol){
		this->pProtocol = protocol;
	}
	virtual void handle(){
		this->pProtocol->AddMoney();
	}
public:
	HandleClientProtocol* pProtocol;
};

//处理玩家升级的请求
class AddLevelCommand : public AbstractCommand{
public:
	AddLevelCommand(HandleClientProtocol* protocol){
		this->pProtocol = protocol;
	}
	virtual void handle(){
		this->pProtocol->addLevel();
	}
public:
	HandleClientProtocol* pProtocol;
};


//服务器程序
class Serser{
public:
	void addRequest(AbstractCommand* command){
		mCommands.push(command);
	}

	void startHandle(){
		while (!mCommands.empty()){
			AbstractCommand* command = mCommands.front();
			command->handle();
			mCommands.pop();
		}
	}
public:
	queue mCommands;
};

void test01(){
	
	HandleClientProtocol* protocol = new HandleClientProtocol;
	//客户端增加金币的请求
	AbstractCommand* addmoney = new AddMoneyCommand(protocol);
	//客户端升级请求
	AbstractCommand* addlevel = new AddLevelCommand(protocol);

	Serser* server = new Serser;
	//将客户端请求加入到处理的队列中
	server->addRequest(addmoney);
	server->addRequest(addlevel);

	//服务器开始处理请求
	server->startHandle();
}

int main(){
	test01();
	return 0;
}

优点：

（1）降低系统耦合度，请求者和接收者之间完全解耦

（2）新命令可以很容易添加，无需修改源代码，满足开闭原则

缺点：

（1）可能会有过多的具体命令类

适用场景：

（1）请求者无需知道接收者的任何信息

（2）系统需要将一组 *** 作组合在一起形成宏命令

定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。可以看成诸葛亮的锦囊妙计，一个锦囊代表一个策略；卡牌游戏的一张卡触发的效果也算是一个策略。

#include 
using namespace std;

//抽象武器 武器策略 
class WeaponStrategy{
public:
	virtual void UseWeapon() = 0;
};

class Knife : public WeaponStrategy{
public:
	virtual void UseWeapon(){
		cout << "使用匕首！" << endl;
	}
};

class AK47 :public WeaponStrategy{
public:
	virtual void UseWeapon(){
		cout << "使用AK47！" << endl;
	}
};

class Character {
public:
	void setWeapon(WeaponStrategy* weapon){
		this->pWeapon = weapon;
	}
	void ThrowWeapon(){
		this->pWeapon->UseWeapon();
	}
public:
	WeaponStrategy* pWeapon;
};


void test01(){
	//创建角色
	Character* character = new Character;

	//武器策略
	WeaponStrategy* knife = new Knife;
	WeaponStrategy* ak47 = new AK47;

	character->setWeapon(knife);
	character->ThrowWeapon();

	character->setWeapon(ak47);
	character->ThrowWeapon();

	delete ak47;
	delete knife;
	delete character;
}

int main(){
	test01();
	return 0;
}

优点：

（1）算法可以自由切换

（2）避免使用多重条件判断

（3）扩展性良好，符合开闭原则

缺点：

（1）策略类数量可能过多，细小的变化都将导致系统要增加一个新的具体策略类

（2）所有策略类都需要对外暴露

适用场景：

（1）一个系统需要动态地在几种算法中选择一种

当对象间存在一对多关系时，则使用观察者模式。比如当一个对象被修改时，则会自动通知依赖它的对象。这个案例非常多，比如红绿灯的变化会改变车辆的状态，拍卖会，警报等。在观察者模式中，发生改变的对象称为观察目标，而被通知的对象称为观察者。

#include 
#include 
using namespace std;

//抽象的英雄 抽象的观察者
class AbstractHero{
public:
	virtual void Update() = 0;
};

//具体英雄  具体观察者
class HeroA :public AbstractHero{
public:
	HeroA(){
		cout << "英雄A正在攻击BOSS ..." << endl;
	}
	virtual void Update(){
		cout << "英雄A停止攻击,进入待机状态..." << endl;
	}
};

class HeroB :public AbstractHero{
public:
	HeroB(){
		cout << "英雄B正在攻击BOSS ..." << endl;
	}
	virtual void Update(){
		cout << "英雄B停止攻击,进入待机状态..." << endl;
	}
};

class HeroC :public AbstractHero{
public:
	HeroC(){
		cout << "英雄C正在攻击BOSS ..." << endl;
	}
	virtual void Update(){
		cout << "英雄C停止攻击,进入待机状态..." << endl;
	}
};

//观察目标抽象
class AbstractBoss{
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero) = 0;
	//删除观察者
	virtual void deleteHero(AbstractHero* hero) = 0;
	//通知所有观察者
	virtual void notify() = 0; 
};

//具体的观察者 BOSSA
class BOSSA : public AbstractBoss{
public:
	virtual void addHero(AbstractHero* hero){
		pHeroList.push_back(hero);
	}
	//删除观察者
	virtual void deleteHero(AbstractHero* hero){
		pHeroList.remove(hero);
	}
	//通知所有观察者
	virtual void notify(){
		for (list::iterator it = pHeroList.begin(); it != pHeroList.end();it ++){
			(*it)->Update();
		}
	}
public:
	list pHeroList;
};

void test01(){
	//创建观察者
	AbstractHero* heroA = new HeroA;
	AbstractHero* heroB = new HeroB;
	AbstractHero* heroC = new HeroC;

	//创建观察目标
	AbstractBoss* bossA = new BOSSA;
	bossA->addHero(heroA);
	bossA->addHero(heroB);
	bossA->addHero(heroC);

	cout << "heroB阵亡..." << endl;
	bossA->deleteHero(heroB);

	cout << "Boss阵亡...通知其他英雄停止攻击..." << endl;
	bossA->notify();
}

int main(){
	test01();
	return 0;
}

优点：

（1）观察者和被观察者是抽象耦合的

（2）建立了一套触发机制

（3）简化了一对多的设计难度

缺点：

（1）如果一个被观察对象有很多直接或间接地观察者的话，通知花费的总时间会较多

（2）不能有循环依赖，否则会重复通知最后崩溃

（3）观察者仅仅知道发生了什么变化，但不知道如何变化的

适用场景：

（1）一个对象改变将导致其它对象也发生改变，而不需要知道具体由多少对象改变，降低耦合度

（2）需要创建触发链，A影响B，B影响C

（3）一个抽象模型有两方面，其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中使他们可以各自独立的改变和复用。（一个对象改变会引起另一个对象改变，就可以看成观察者依赖于观察对象）

设计模式需要大量的编程项目积累才能有比较深刻的感悟，不限语言，在于思想。

此文基于黑马程序员的C++设计模式课程（主要是例子）与菜鸟教程