设计模式——行为型模式

最新推荐文章于 2024-01-07 19:00:10 发布

ljaac

最新推荐文章于 2024-01-07 19:00:10 发布

阅读量329

点赞数 1

分类专栏：设计模式文章标签：设计模式责任链模式模板方法模式策略模式观察者模式

本文链接：https://blog.csdn.net/m0_47830029/article/details/126763318

版权

设计模式专栏收录该内容

10 篇文章 1 订阅

订阅专栏

前言

本文只是记录本人学习设计模式时记录的一些学习笔记，可能不全，但是可以做到一些提醒记忆的作用，如有侵权，联系删改，文章后会贴出学习时参考的链接。此前言适用于本人所写设计模式系列。

行为型模式

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

14. 模板方法（Template Method）

它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤

结构：

Abstract Class
抽象类的父类
Concrete Class
具体的实现子类
template Method()
模板方法
method 1()与method 2()
具体步骤方法

示例：

煮茶和煮咖啡的步骤是一样的，但是其具体操作不同，可以修改器具体操作而不更改其步骤

class DrinkTemplate
{
public:
    virtual void BoildWater() = 0;
    virtual void Brew() = 0;
    virtual void PourInCup() = 0;
    virtual void AddSomethin() = 0;
    void Make()
    {
        BoildWater();
        Brew();
        PourInCup();
        AddSomethin();
    }
};
class Coffee : public DrinkTemplate
{
    virtual void BoildWater()
    {
        cout << "煮水……" << endl;
    }
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    virtual void PourInCup()
    {
        cout << "把咖啡倒入杯中……" << endl;
    }
    virtual void AddSomethin()
    {
        cout << "加糖，加牛奶……" << endl;
    }
};
class Tea : public DrinkTemplate
{
    virtual void BoildWater()
    {
        cout << "煮水……" << endl;
    }

    virtual void Brew()
    {
        cout << "冲泡茶叶" << endl;
    }
    virtual void PourInCup()
    {
        cout << "把茶水倒入杯中……" << endl;
    }
    virtual void AddSomethin()
    {
        cout << "加柠檬……" << endl;
    }
};

15. 策略（Strategy）

定义了一系列的算符，并将每一个算法封装起来，而且使他们还可以相互替换。

结构：

Strategy:
策略（算法）抽象。
ConcreteStrategy
各种策略（算法）的具体实现。
Context
策略的外部封装类，或者说策略的容器类。根据不同策略执行不同的行为。策略由外部环境决定。

示例：

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;
};

16. 命令（Command）

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。

结构：

Command
Command命令的抽象类。
Concrete Command
Command的具体实现类。
Receiver
需要被调用的目标对象。
Invoker
通过Invoker执行Command对象。

示例：

将客户端的指令传入服务器的队列中，再依次处理

#include <iostream>
#include <queue>
#include <windows.h>
using namespace std;
class HandleClientProtocol
{
public:
    void AddMoney()
    {
        cout << "Money++..." << endl;
    }
    void AddDiamond()
    {
        cout << "Diamond++..." << endl;
    }
    void AddEquipment()
    {
        cout << "Add Equipment..." << endl;
    }
    void AddLevel()
    {
        cout << "Leve+1!" << 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 AddDiamondCommand :public AbstractCommand
{
public:
    AddDiamondCommand(HandleClientProtocol* protocol)
    {
        this->pProtocol = protocol;
    }
    virtual void handle()
    {
        this->pProtocol->AddDiamond();
    }
public:
    HandleClientProtocol* pProtocol;
};
class AddEquipmentCommand :public AbstractCommand
{
public:
    AddEquipmentCommand(HandleClientProtocol* protocol)
    {
        this->pProtocol = protocol;
    }
    virtual void handle(){
        this->pProtocol->AddEquipment();
    }
public:
    HandleClientProtocol* pProtocol;
};
class AddLevelCommand :public AbstractCommand
{
public:
    AddLevelCommand(HandleClientProtocol* protocol)
    {
        this->pProtocol = protocol;
    }
    virtual void handle()
    {
        this->pProtocol->AddLevel();
    }
public:
    HandleClientProtocol* pProtocol;
};
class Server
{
public:
    void addRequest(AbstractCommand* command)
    {
        mCommands.push(command);
    }
    void startHandle()
    {
        while(!mCommands.empty())
        {
            Sleep(2000);
            AbstractCommand* command = mCommands.front();
            command->handle();
            mCommands.pop();
        }
    }
public:
    queue<AbstractCommand*> mCommands;
};

int main()
{
    HandleClientProtocol* protocol = new HandleClientProtocol;
    AbstractCommand* addmoney = new AddMoneyCommand(protocol);
    AbstractCommand* adddiamond = new AddDiamondCommand(protocol);
    AbstractCommand* addequipment = new AddEquipmentCommand(protocol);
    AbstractCommand* addlevel = new AddLevelCommand(protocol);
    
    Server* server = new Server;
    server->addRequest(addmoney);
    server->addRequest(adddiamond);
    server->addRequest(addequipment);
    server->addRequest(addlevel);
    server->startHandle();
    return 0;
}

17. 观察者（Observer）

多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为

结构：

Subject（被观察者）
被观察的对象。当需要被观察的状态发生变化时，需要通知队列中所有观察者对象。Subject需要维持（添加，删除，通知）一个观察者对象的队列列表。
Concrete Subject
被观察者的具体实现。包含一些基本的属性状态及其他操作。
Observer（观察者）
接口或抽象类。当Subject的状态发生变化时，Observer对象将通过一个callback函数得到通知。
Concrete Observer
观察者的具体实现。得到通知后将完成一些具体的业务逻辑处理。

示例：

将BOSSA和HeroA,B,C,D的状态关联起来，BOSS的状态改变，Hero的状态跟着改变

#include <iostream>
#include <list>
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停止打BOSS，待机状态……" << endl;
    }
};

class HeroB : public AbstractHero
{
public:
    HeroB(){
        cout << "英雄B正在打BOSS……" << endl;
    }
    virtual void Update(){
        cout << "英雄B停止打BOSS，待机状态……" << endl;
    }
};
class HeroC : public AbstractHero
{
public:
    HeroC(){
        cout << "英雄C正在打BOSS……" << endl;
    }
    virtual void Update(){
        cout << "英雄C停止打BOSS，待机状态……" << endl;
    }
};
class HeroD : public AbstractHero
{
public:
    HeroD(){
        cout << "英雄D正在打BOSS……" << endl;
    }
    virtual void Update(){
        cout << "英雄D停止打BOSS，待机状态……" << endl;
    }
};
class AbstractBOSS
{
public:
    virtual void addHero(AbstractHero* hero) = 0;
    virtual void deleteHero(AbstractHero* hero) = 0;
    virtual void notify() = 0;
};
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<AbstractHero*>::iterator it = pHeroList.begin(); it != pHeroList.end(); it++)
        {
            (*it)->Update();
        }
    }
public:
    list<AbstractHero*> pHeroList;
};
int main()
{
    AbstractHero* heroA = new HeroA;
    AbstractHero* heroB = new HeroB;
    AbstractHero* heroC = new HeroC;
    AbstractHero* heroD = new HeroD;
    AbstractBOSS* bossA = new BOSSA;
    bossA->addHero(heroA);
    bossA->addHero(heroB);
    bossA->addHero(heroC);
    bossA->addHero(heroD);
    cout << "heroC阵亡……" << endl;
    bossA->deleteHero(heroC);
    cout << "BOSSA被击杀……" << endl;
    bossA->notify();
    return 0;
}

18. 责任链（Chain of Responsibility）

允许你将请求沿着处理者链进行发送。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。

结构：

Handler
处理类的抽象父类。
concrete Handler
具体的处理类。

示例：

将造车过程链式为造车头-造车身-造车尾，造完车头后会自动造车身，造完车身后会自动造车尾

class CarHandle
{
public:
    virtual void HandleCar() = 0;
    void setNextHandle(CarHandle *handle)
    {
        this->m_handle = handle;
    }
protected:
    CarHandle *m_handle;
};
class HeadCarHandel : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造车头……" << endl;
        if(m_handle != NULL){
            m_handle->HandleCar();
        }
    }
};
class BodyCarHandel : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造车身……" << endl;
        if(m_handle != NULL){
            m_handle->HandleCar();
        }
    }
};
class TailCarHandel : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造车尾……" << endl;
        if(m_handle != NULL){
            m_handle->HandleCar();
        }
    }
};

19. 迭代器（Iterator）

提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

结构：

Iterator（迭代器接口）：
该接口必须定义实现迭代功能的最小定义方法集
比如提供hasNext()和next()方法。
ConcreteIterator（迭代器实现类）：
迭代器接口Iterator的实现类。可以根据具体情况加以实现。
Aggregate（容器接口）：
定义基本功能以及提供类似Iterator iterator()的方法。
concreteAggregate（容器实现类）：
容器接口的实现类。必须实现Iterator iterator()方法。

示例：

#include <iostream>
using namespace std;
typedef int Object;
#define SIZE 5
class MyIterator
{
public:
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() = 0;
    virtual Object CurrentItem() = 0;
    virtual ~MyIterator(){}
};
class Aggregate
{
public:
    virtual MyIterator *CreatelIterator() = 0;
    virtual Object getItem(int index) = 0;
    virtual int getSize() = 0;
    virtual ~Aggregate(){}
};
class ConterteIterator : public MyIterator
{
public:
    ConterteIterator(Aggregate *ag)
    {
        this->_ag = ag;
        this->_current_index = 0;
    }
    virtual void First()
    {
        _current_index = 0;
    }
    virtual void Next()
    {
        if(_current_index < _ag->getSize()){
            _current_index++;
        }
    }
    virtual bool IsDone()
    {
        return (_current_index == _ag->getSize());
    }
    virtual Object CurrentItem()
    {
        return _ag->getItem(_current_index);
    }
private:
    int _current_index;
    Aggregate *_ag;
};
class ConcreteAggregate : public Aggregate
{
public:
    ConcreteAggregate()
    {
        for(int i = 0; i < SIZE; i++)
        {
            object[i] = i + 100;
        }
    }
    virtual MyIterator *CreatelIterator()
    {
        return new ConterteIterator(this);
    }
    virtual Object getItem(int index)
    {
        return object[index];
    }
    virtual int getSize()
    {
        return SIZE;
    }
private:
    Object object[SIZE];
};

int main()
{
    Aggregate *ag = new ConcreteAggregate;
    MyIterator *it = ag->CreatelIterator();
    for(; !(it->IsDone()); it->Next())
    {
        cout << it->CurrentItem() << endl;
    }
    delete it;
    delete ag;
    return 0;
}

20. 中介者（Mediator）

定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解

结构：

Mediator抽象中介者
中介者类的抽象父类。
concreteMediator
具体的中介者类。
Colleague
关联类的抽象父类。
concreteColleague
具体的关联类

示例：

创建一个Mediator，来降低Man和Woman之间的耦合度，通过Mediator来完成getparter();

#include <iostream>
using namespace std;
class Mediator;
class Person
{
public:
    Person(string name, int sex, int condi, Mediator *m)
    {
        m_name = name;
        m_sex = sex;
        m_condi = condi;
        m_m = m;
    }
    int getCondi()
    {
        return m_condi;
    }
    int getSex()
    {
        return m_sex;
    }
    string getName()
    {
        return m_name;
    }
    Mediator *getM()
    {
        return m_m;
    }
    virtual void getparter(Person *p) = 0;
private:
    string   m_name;
    int      m_sex;
    int      m_condi;
    Mediator *m_m;
};
class Mediator
{
public:
    void setMan(Person *man)
    {
        pMan = man;
    }
    void setWoman(Person *woman)
    {
        pWoman = woman;
    }
    virtual void getParter()
    {
        if(pWoman->getSex() == pMan->getSex()){
            cout << "同性恋不能在一起……" << endl;
        }
        if(pWoman->getCondi() == pMan->getCondi()){
            cout << pWoman->getName() << "和" << pMan->getName() << "绝配" <<endl;
        }
        else{
            cout << pWoman->getName() << "和" << pMan->getName() << "不配" <<endl;
        }
    }
private:
    Person *pMan;
    Person *pWoman;
};
class Woman : public Person
{
public:
    Woman(string name, int sex, int condi, Mediator *m) : Person(name, sex, condi, m) {}
    virtual void getparter(Person *p)
    {
      getM()->setWoman(this);
      getM()->setMan(p);
      getM()->getParter();
    }
};

class Man : public Person
{
public:
    Man(string name, int sex, int condi, Mediator *m) : Person(name, sex, condi, m){
    virtual void getparter(Person *p)
    {
        getM()->setWoman(p);
        getM()->setMan(this);
        getM()->getParter();
    }
};
int main()
{
    Mediator *m = new Mediator;
    Person *xiaofang = new Woman("小芳", 2, 5, m);
    Person *zhangsan = new Man("张三", 1, 4, m);
    Person *lisi = new Man("李四", 1, 5, m);

    xiaofang->getparter(zhangsan);
    xiaofang->getparter(lisi);
    zhangsan->getparter(lisi);
    lisi->getparter(xiaofang);
    return 0;
}

21. 备忘录（Memento）

在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它

结构：

Originator（原生者）
需要被保存状态以便恢复的那个对象。
Memento（备忘录）
该对象由Originator创建，主要用来保存Originator的内部状态。
Caretaker（管理者）
负责在适当的时间保存/恢复Originator对象的状态。

示例：

#include <iostream>
using namespace std;
class Memo
{
public:
    Memo(string name, int age)
    {
        m_name = name;
        m_age = age;
    }
    string getName()
    {
        return m_name;
    }
    int getAge()
    {
        return m_age;
    }
    void setName(string name)
    {
        this->m_name = name;
    }
    void setAge(int age)
    {
        this->m_age = age;
    }
private:
    string m_name;
    int m_age;
};
class Person
{
public:
    Person(string name, int age)
    {
        m_name = name;
        m_age = age;
    }
    void info()
    {
        cout << "name:" << m_name << "\tage:" << m_age << endl;
    }
    string getName()
    {
        return m_name;
    }
    int getAge()
    {
        return m_age;
    }
    void setName(string name)
    {
        this->m_name = name;
    }
    void setAge(int age)
    {
        this->m_age = age;
    }
    Memo* createMemo()
    {
        return new Memo(m_name, m_age);
    }
    void setMemo(Memo* memo)
    {
        this->m_age = memo->getAge();
        this->m_name = memo->getName();
    }
private:
    string m_name;
    int m_age;
};
class Caretaker
{
public:
    Caretaker(Memo *m)
    {
        this->m = m;
    }
    Memo* getMemo()
    {
        return m;
    }
    void setMemo(Memo *m)
    {
        this->m = m;
    }
private:
    Memo *m;
};
int main()
{
    Caretaker *caretaker = NULL;
    Person *p = new Person("小明", 19);
    //Memo *m = NULL;
    p->info();
    caretaker = new Caretaker(p->createMemo());
    p->setAge(20);
    p->setName("小红");
    p->info();
    p->setMemo(caretaker->getMemo());
    p->info();
    delete caretaker;
    return 0;
}

22. 状态（State）

让你能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样。

结构：

Context：用户对象
拥有一个State类型的成员，以标识对象的当前状态；
State：接口或基类
封装与Context的特定状态相关的行为；
ConcreteState：接口实现类或子类
实现了一个与Context某个状态相关的行为。

示例：

#include <iostream>
using namespace std;
class Worker;
class State
{
public:
    virtual void doSomeThing(Worker *w) = 0;
};
class Worker
{
public:
    Worker();
    int getHour()
    {
        return m_hour;
    }
    void setHour(int hour)
    {
        m_hour = hour;
    }
    State* getCurrentState()
    {
        return m_currstate;
    }
    void setCurrentState(State* state)
    {
        m_currstate = state;
    }
    void doSomeThing() //
    {
        m_currstate->doSomeThing(this);
    }
private:
    int		m_hour;
    State	*m_currstate; //对象的当前状态
};
class State1 : public State
{
public:
     void doSomeThing(Worker *w);
};
class State2  : public State
{
public:
     void doSomeThing(Worker *w);
};
void State1::doSomeThing(Worker *w)
{
    if (w->getHour() == 7 || w->getHour()==8)
    {
        cout << "吃早饭" << endl;
    }
    else
    {
        delete w->getCurrentState();  //状态1 不满足 要转到状态2
        w->setCurrentState(new State2 );
        w->getCurrentState()->doSomeThing(w); //
    }
}

void State2::doSomeThing(Worker *w)
{
    if (w->getHour() == 9 || w->getHour()==10)
    {
        cout << "工作" << endl;
    }
    else
    {
        delete w->getCurrentState(); //状态2 不满足 要转到状态3 后者恢复到初始化状态
        w->setCurrentState(new State1); //恢复到当初状态
        cout << "当前时间点：" << w->getHour() << "未知状态" << endl;
    }
}
Worker::Worker()
{
    m_currstate = new State1;
}
int main()
{
    Worker *w1 = new Worker;
    w1->setHour(7);
    w1->doSomeThing();
    w1->setHour(9);
    w1->doSomeThing();
    delete w1;
    return 0;
}

23. 访问者（Visitor）

在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问

结构：

抽象访问者（Visitor）角色
声明了一个或者多个访问操作，形成所有的具体元素角色必须实现的接口。
具体访问者（ConcreteVisitor）角色
实现抽象访问者角色所声明的接口，也就是抽象访问者所声明的各个访问操作。
抽象节点（Element）角色
声明一个接受操作，接受一个访问者对象作为一个参量。
具体节点（ConcreteElement）角色
实现了抽象元素所规定的接受操作。
结构对象（ObiectStructure）角色
有如下的一些责任，可以遍历结构中的所有元素；如果需要，提供一个高层次的接口让访问者对象可以访问每一个元素；如果需要，可以设计成一个复合对象或者一个聚集，如列（List）或集合（Set）。

示例：

class Visitor;
class ParkElement
{
public:
    virtual void accept(Visitor *visitor) = 0;
    virtual string getName() = 0;
    virtual ~ParkElement(){}
private:
    string m_name;
};
class Visitor
{
public:
    virtual void visit(ParkElement *park) = 0;
    virtual ~Visitor(){}

};
class VisitorA : public Visitor
{
public:
    virtual void visit(ParkElement *park)
    {
        this->m_park = park;
        cout << this->getName() << "打扫了" << park->getName() << endl;
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "VisitorA";
    ParkElement* m_park;
};
class VisitorB : public Visitor
{
public:
    virtual void visit(ParkElement *park)
    {
        this->m_park = park;
        cout << this->getName() << "打扫了" << park->getName() << endl;
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "VisitorB";
    ParkElement* m_park;
};
class ParkA : public ParkElement
{
public:
    virtual void accept(Visitor *visitor)
    {
        visitor->visit(this);
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "ParkA";
};

class ParkB : public ParkElement
{
public:
    virtual void accept(Visitor *visitor)
    {
        visitor->visit(this);
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "ParkB";
};
class ManagerVisitor : public Visitor
{
    virtual void visit(ParkElement *park)
    {
        this->m_park = park;
        cout << this->getName() << "访问了" << park->getName() << endl;
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "Manager";
    ParkElement* m_park;
};
class Park : public ParkElement
{
public:
    Park()
    {
        m_list.clear();
    }
    void setParkElement (ParkElement *ipark)
    {
        m_list.push_back(ipark);
    }
    virtual void accept(Visitor *visitor)
    {
        for(list<ParkElement *>::iterator it = m_list.begin(); it != m_list.end(); it++)
        {
            //visitor->visit(*it);
            (*it)->accept(visitor);
        }
    }
    virtual string getName()
    {
        return m_name;
    }
private:
    string m_name = "Park";
    list<ParkElement *> m_list;
};

24. 解释器（Interpreter）

为语言创建解释器，通常由语言的语法和语法分析来定义

结构：

Context
解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
AbstractExpression
解释器抽象类。
ConcreteExpression
解释器具体实现类。

示例：

#include <iostream>
using namespace std;
class Context
{
public:
    Context(int num)
    {
        this->m_num = num;
    }
    int getNum()
    {
        return m_num;
    }
    int getRes()
    {
        return m_res;
    }
    void setNum(int num)
    {
        this->m_num = num;
    }
    void setRes(int res)
    {
        this->m_res = res;
    }
private:
    int m_num;
    int m_res;
};

class Expression
{
public:
    virtual void interperter(Context *context) = 0;
};
class PlusExpression : public Expression
{
public:
    PlusExpression()
    {
        this->m_context = NULL;
    }
    virtual void interperter(Context *context)
    {
        int num = context->getNum();
        num++;
        context->setNum(num);
        context->setRes(num);
    }
private:
    Context *m_context;
};
class MinusExpression : public Expression
{
public:
    MinusExpression()
    {
        this->m_context = NULL;
    }
    virtual void interperter(Context *context)
    {
        int num = context->getNum();
        num--;
        context->setNum(num);
        context->setRes(num);
    }
private:
    Context *m_context;
};
int main()
{
    Expression *e = NULL;
    Context *c = NULL;
    c = new Context(10);
    cout << c->getNum() << endl;
    e = new PlusExpression;
    e->interperter(c);
    cout << c->getRes() << endl;
    delete  e;
    e = new MinusExpression;
    e->interperter(c);
    cout << c->getRes() << endl;
    delete e;
    delete c;
    return 0;
}