设计模式学习记录

创建型

与对象的创建有关

抽象工厂模式

提供一个创建一系列相关或相互依赖的对象的接口

//来1张1费卡  1张2费卡 一系列相关
class Card {
public:
	virtual void out() = 0;
};
//还可以定义更多的卡牌
class CardCost1:public Card {
public:
	virtual void out() {
		cout << "我是1费卡" << endl;
	}
};

class CardCost2 :public Card {
public:
	virtual void out() {
		cout << "我是2费卡" << endl;
	}
};

class Factory {
public:
	virtual Card* CreateCost1() = 0;
	virtual Card* CreateCost2() = 0;
};
//还可以定义更多的工厂来组合
class CardFactory:public Factory {
public:
	Card* CreateCost1() {//来一张1费卡
		return new CardCost1();
	}
	Card* CreateCost2() {//来一张2费卡
		return new CardCost2();
	}
};
class CardFamaly
int main() {
	CardFactory *fac = new CardFactory();
	Card* cost1 = fac->CreateCost1();
	Card* cost2 = fac->CreateCost2();

	cost1->out();
	cost2->out();
	delete cost1;
	delete cost2;
	delete fac;
	return 0;
}

工厂模式

定义一个用于创建对象的接口,让子类决定实例化哪个类
//和抽象工厂区别是 1个和多个？

class Card {
public:
	virtual void out() = 0;
};

class CardCost1:public Card {
public:
	virtual void out() {
		cout << "我是1费卡" << endl;
	}
};

class CardCost2 :public Card {
public:
	virtual void out() {
		cout << "我是2费卡" << endl;
	}
};
class Factory {
public:
	virtual Card* Create() = 0;
};


class CardCost1Factory:public Factory {
public:
	Card* Create() {
		return new CardCost1();
	}
};

class CardCost2Factory :public Factory {
public:
	Card* Create() {
		return new CardCost2();
	}
};
int main() {
	CardCost1Factory* fac1 = new CardCost1Factory();
	CardCost2Factory* fac2 = new CardCost2Factory();
	Card* cost1 = fac1->Create();
	Card* cost2 = fac2->Create();

	cost1->out();
	cost2->out();
	delete cost1;
	delete cost2;
	delete fac1;
	delete fac2;
	return 0;
}

生成器模式

在某些情况下，一个对象的创建过程非常复杂，涉及多个步骤，每个步骤都可能有不同的实现方式。如果将所有创建逻辑放在一个类中，会导致该类变得庞大且难以维护。此外，如果需要创建不同的变体对象，就需要在该类中添加更多的逻辑，使得代码变得混乱。

原型模式

克隆

单例模式

就是单例

结构型

适配器模式

将一个类的接口转变为另外一个希望的接口

template<typename Type>
void permutation(Type first, int len) {
	int val = 1;
	for (int i = 0; i < len; i++) {
		*first = val;
		val++;
		first++;
	}
}

int main() {
	vector<int> a;
	//本来vector 不能用 = int 赋值 ++
	//把vector =>back_insert_iterator(重载++ = ) 调用vector push_back
	permutation(back_inserter(a), 10);
	int b[20];
	permutation(b, 10);
	return 0;
}

桥接模式

将抽象部分和其实现部分分离,使它们都可以独立的变化

//羁绊
class Jiban {
public:
	virtual void out() = 0;
};

class Family :public Jiban {
public:
	virtual void out() {
		cout << " 家人 " << endl;
	}
};

class ZhenMan :public Jiban {
public:
	virtual void out() {
		cout << " 铁血屈服者 " << endl;
	}
};
//英雄
class Hero {
public:
	virtual void out() = 0;
	virtual void SetJiban(Jiban* jb) = 0;
	Jiban* m_jb = nullptr;
};

class BaoBao:public Hero {
public:
	virtual void out() {
		cout << " 爆爆 ";
		m_jb->out();
	}
	virtual void SetJiban(Jiban* jb) {
		m_jb = jb;
	}
	
};

class JieSi :public Hero {
public:
	virtual void out() {
		cout << " 杰斯 ";
		m_jb->out();
	}
	virtual void SetJiban(Jiban* jb) {
		m_jb = jb;
	}
};

int main() {
	Family* family = new Family;
	ZhenMan* zm = new ZhenMan;

	JieSi* js = new JieSi();
	BaoBao* bb = new BaoBao();

	js->SetJiban(zm);
	bb->SetJiban(family);

	js->out();
	bb->out();
	return 0;

}

组合模式

将对象组合成树型结构以表示整体与部分的层次结构
文件系统

装饰模式

动态的给一个对象添加一些额外的职责

class Water {
public:
	virtual int cost() = 0;
	virtual void out() = 0;
};

class Wahaha :public Water {
public:
	virtual int cost() {
		return 2;
	}
	virtual void out() {
		cout << "娃哈哈";
	}
};

class WaterDecorator :public Water {
public:
	WaterDecorator(Water* self) {
		m_self = self;
	}
	virtual int cost() {
		return m_self->cost();
	}
	virtual void out() {
		m_self->out();
	}
	Water* m_self;
};
//加冰
class IceDecorator :public WaterDecorator {
public:
	IceDecorator(Water* self) :WaterDecorator(self) {}
	virtual int cost() {
		return 1 + m_self->cost();
	}
	virtual void out() {
		m_self->out();
		cout << " 加冰 ";
	}
};
//加糖
class SugarDecorator :public WaterDecorator {
public:
	SugarDecorator(Water* self) :WaterDecorator(self) {}
	virtual int cost() {
		return 1 + m_self->cost();
	}
	virtual void out() {
		m_self->out();
		cout << " 加糖 ";
	}
};

int main() {
	Wahaha* whh = new Wahaha();
	{
		IceDecorator* d = new IceDecorator(whh);
		SugarDecorator* d2 = new SugarDecorator(d);
		d2->out();
		cout << d2->cost() << endl;
	}
	return 0;
}

外观模式

为子系统中一组接口提供一个一致的界面

class Computer {
public:
	void turnOn() {
		cout << " 开电脑 ";
	}
	void turnOff() {
		cout << " 关电脑 ";
	}
};
class Light {
public:
	void turnOn() {
		cout << " 开灯 ";
	}
	void turnOff() {
		cout << " 关灯 ";
	}
};

class MyLife {
	Computer computer;
	Light light;
public:
	void play() {
		computer.turnOn();
		light.turnOn();
		cout << endl;
	}
	void sleep() {
		computer.turnOff();
		light.turnOff();
		cout << endl;
	}
};

int main() {
	MyLife* mf = new MyLife;
	mf->play();
	mf->sleep();
	return 0;
}

享元模式

运用共享技术有效的支持大量细粒度的对象

struct Base {
public:
	string name;
	int gongji;//攻击
	int fangyu;//防御
};

class BaoBao{
public:
	BaoBao(Base *base) {
		m_base = base;
		x = y = 0;
	}
	
	Base* m_base;
	int x, y;//坐标
};

class BaoBaoFactory {

public:
	BaoBao* GetHero() {
		Base* base = nullptr;
		if (mmp.count("爆爆"))base = mmp["爆爆"];
		else {
			base = new Base;
			base->name = "爆爆";
			base->gongji = 999;
			base->fangyu = 999;
			mmp[base->name] = base;
		}
		return new BaoBao(base);
	}
	unordered_map<string, Base *> mmp;
};

int main() {
	BaoBaoFactory* fac = new BaoBaoFactory();
	vector<BaoBao* > all;

	for (int i = 0; i < 100; i++) {
		all.push_back(fac->GetHero());
	}
	return 0;
}

代理模式

行为型

行为模式涉及算法和对象间职责的分配。行为模式不仅描述对象或类的模式，还描述它们之间的通信模式

责任链模式

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递改请求，直到有一个对象处理它为止。

class Request {
public:
	Request(int m, string i) :money(m), info(i) {}
	int money;
	string info;
};

class RequestHandler {
public:
	virtual void DoHandle(Request* req) = 0;
	void SetHandler(RequestHandler* handler) {
		m_handler = handler;
	}
	RequestHandler* m_handler = nullptr;
};

class Father :public RequestHandler {
public:
	virtual void DoHandle(Request* req) {
		if (req->money <= 20) {
			cout << "Father Handler,give money = " << req->money << endl;
		}
		else if (m_handler) {
			req->money += 1000;
			m_handler->DoHandle(req);
		}
	}
};

class Mother :public RequestHandler {
public:
	virtual void DoHandle(Request* req) {
		if (req->money <= 5000) {
			cout << "Mother Handler,give money = " << req->money << endl;
		}
		else if (m_handler) {
			m_handler->DoHandle(req);
		}
	}
};

int main() {

	Request* r = new Request(500, "补课费");

	Father* f = new Father();
	Mother* m = new Mother();
	f->SetHandler(m);

	f->DoHandle(r);
	return 0;
}

命令模式

将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销操作。

class Light {
public:
	void TurnOn() {
		cout << "light TurnOn" << endl;
	}
	void TurnOff() {
		cout << "light TurnOff" << endl;
	}
};

class Command {
public:
	virtual void exe() = 0;
};

class OpenCommand :public Command {
public:
	void setLight(Light* light) {
		m_light = light;
	}
	virtual void exe() {
		m_light->TurnOn();
	}
	Light* m_light;
};

class CloseCommand :public Command {
public:
	void setLight(Light* light) {
		m_light = light;
	}
	virtual void exe() {
		m_light->TurnOff();
	}
	Light* m_light;
};

int main() {
	Light* light = new Light;

	OpenCommand* open = new OpenCommand;
	CloseCommand* close = new CloseCommand;

	open->setLight(light);
	close->setLight(light);

	open->exe();
	close->exe();
	return 0;
}

解释器模式

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

迭代器模式

提供一种顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。

中介者模式

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互。

class User;
class middleman {
public:
	virtual void sendMessage(string &msg, User* sender) = 0;
	virtual void addUser(User* user) = 0;
};

class User {
public:
	User(string name, middleman* middleman):m_name(name),m_middleman(middleman){
		middleman->addUser(this);
	}
	void sendMessage(string &msg) {
		cout << m_name << ":Say " << msg << endl;
		m_middleman->sendMessage(msg,this);
	}
	void recvMessage(string& msg) {
		cout << m_name << ":Recv " << msg << endl;
	}
	string m_name;
	middleman* m_middleman;
};

class ChatRoom :public middleman {
	vector<User*> m_all;
public:
	virtual void sendMessage(string &msg,User * sender) {
		for (auto user : m_all) {
			if (user == sender)continue;
			user->recvMessage(msg);
		}
	}
	virtual void addUser(User* user) {
		m_all.push_back(user);
	}
};

int main() {
	ChatRoom* room = new ChatRoom();
	User* user1 = new User("小明", room);
	User* user2 = new User("小花", room);
	User* user3 = new User("康康", room);

	string msg = "How are you";
	user3->sendMessage(msg);
	return 0;
}

备忘录模式

在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复原先保存的状态。

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
和中介者模式区别 1对多 和 多对多 树和图？

//观察者
class Observer {
public:
	virtual void update(int state) = 0;
};

class ActObserver:public Observer {
public:
	ActObserver(string name, int state) :m_name(name), m_state(state) {}
	virtual void update(int state) {
		m_state = state;
		cout << m_name << ":update state = " << m_state << endl;
	}
private:
	string m_name;
	int m_state;
};


//主题
class Subject {
public:
	virtual void addObserver(Observer *observer) = 0;
	virtual void removeObserver(Observer* observer) = 0;
	virtual void notify() = 0;
};

class ActSubject {
public:
	virtual void addObserver(Observer* observer) {
		m_all.insert(observer);
	}
	virtual void removeObserver(Observer* observer) {
		m_all.erase(observer);
	}
	virtual void notify() {
		for (auto ob : m_all) {
			ob->update(m_state);
		}
	}
public:
	void setState(int state) { 
		m_state = state;
		notify();
	}
private:
	set<Observer*> m_all;
	int m_state;
};

int main() {
	ActObserver* aob = new ActObserver("小美", 0);
	ActObserver* aob2 = new ActObserver("小帅", 0);

	ActSubject* sub = new ActSubject();
	sub->addObserver(aob);
	sub->addObserver(aob2);

	sub->setState(2);
	sub->removeObserver(aob);

	sub->setState(1);
	return 0;
}

状态模式

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
把一堆if else 放到一个一个单独的类中处理

class State;
class Context {
public:
	virtual void SetState(State* state) = 0;
};

class State {
public:
	virtual void handle(Context* context) = 0;
	Context *m_context = nullptr;
};

class StateA :public State {
public:
	virtual void handle(Context* context) {
		cout << "StateA" << endl;
		//本来 if else 一坨 把每个状态拆在一个单独的类中处理 
		context->SetState(this);
	}
};

class StateB :public State {
public:
	virtual void handle(Context* context) {
		cout << "StateB" << endl;
		context->SetState(this);
	}
};

class ContextA :public Context {
public:
	ContextA() {
		m_state = new StateA();
	}
	virtual void SetState(State* state) {
		m_state = state;
	}
	void ChangeState(State* state) {
		state->handle(this);
	}
	State* m_state;
};


int main() {
	StateA* A = new StateA();
	StateB* B = new StateB();

	ContextA* C = new ContextA();
	C->ChangeState(A);
	C->ChangeState(B);
	C->ChangeState(A);
	return 0;
}

策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。此模式使得算法可以独立于使用它们的客户而变化。

class MathOperation {
public:
	virtual int DoOperation(int a, int b) = 0;
};
class Add :public MathOperation {
public:
	virtual int DoOperation(int a, int b) {//a^2 + b
		return a * a + b;
	}
};

class Sub :public MathOperation {
public:
	virtual int DoOperation(int a, int b) {//a - b^2
		return a - b * b;
	}
};

class Calc {
public:
	void SetOperation(MathOperation* op) { m_op = op; }
	int DoIt(int a, int b) {
		return m_op->DoOperation(a, b);
	}
private:
	MathOperation* m_op;
};

int main() {
	Add* add = new Add();
	Sub* sub = new Sub();

	Calc* calc = new Calc();
	calc->SetOperation(add);

	cout << "DoIt = " << calc->DoIt(1,2) << endl;
	calc->SetOperation(sub);
	cout << "DoIt = " << calc->DoIt(3, 4) << endl;
	return  0;
}

模版方法模式

定义一个操作中的算法骨架，而将一些步骤延迟到子类中。

class Hero {
public:
	virtual int getHurt() {//伤害计算算法
		return getPhysicsHurt() + getMagicHurt();
	}
public:
	virtual int getPhysicsHurt() = 0;//物理伤害
	virtual int getMagicHurt() = 0;//魔法伤害
	virtual string getName() = 0;

};
//爆爆
class BaoBao:public Hero {
public:
	BaoBao(string name) :m_name(name) {}
	virtual int getPhysicsHurt() {
		return 50;
	}
	virtual int getMagicHurt() {
		return 100;
	}
	virtual string getName() {
		return m_name;
	}
	string m_name;
};

//杰斯 
class JieSi :public Hero {
public:
	JieSi(string name) :m_name(name) {}
	virtual int getPhysicsHurt() {
		return 200;
	}
	virtual int getMagicHurt() {
		return 20;
	}
	virtual string getName() {
		return m_name;
	}
	string m_name;
};

int main() {
	BaoBao* bb = new BaoBao("爆爆");
	JieSi* js = new JieSi("杰斯");

	cout << bb->getName() << " Hart = " << bb->getHurt() << endl;
	cout << js->getName() << " Hart = " << js->getHurt() << endl;
	return 0;
}

访问者模式

表示一个作用于某对象结构中的元素的操作。它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。
英雄带装备

class Hero {
public:
	virtual int getPhysicsHurt() = 0;//物理伤害
	virtual int getMagicHurt() = 0;//魔法伤害
	virtual string getName() = 0;
};
//爆爆
class BaoBao:public Hero {
public:
	BaoBao(string name) :m_name(name) {}
	virtual int getPhysicsHurt() {
		return 50;
	}
	virtual int getMagicHurt() {
		return 100;
	}
	virtual string getName() {
		return m_name;
	}
	string m_name;
};

//杰斯 
class JieSi :public Hero {
public:
	JieSi(string name) :m_name(name) {}
	virtual int getPhysicsHurt() {
		return 200;
	}
	virtual int getMagicHurt() {
		return 20;
	}
	virtual string getName() {
		return m_name;
	}
	string m_name;
};


class Equipment {
public:
	virtual int getHurt(Hero* hero) = 0;
};
//帽子
class Maozi :public Equipment {
public:
	Maozi() {
		m_name = "帽子";
		dPhysicsRate = 1.1;
		dMagicRate = 2.0;
	}
	virtual int getHurt(Hero* hero) {
		int ans = hero->getPhysicsHurt()* dPhysicsRate + hero->getMagicHurt() * dMagicRate;
		cout << m_name << " " << hero->getName() << ":" << ans << endl;
		return ans;
	}
private:
	double dPhysicsRate;
	double dMagicRate;
	string m_name;
};

int main() {
	BaoBao* bb = new BaoBao("爆爆");
	JieSi* js = new JieSi("杰斯");


	Maozi* mz = new Maozi();

	mz->getHurt(bb);

	mz->getHurt(js);
	return 0;
}