设计模式学习记录

创建型

与对象的创建有关

抽象工厂模式

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

//来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_backpermutation(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 + breturn a * a + b;}
};class Sub :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a - b^2return 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;
}