5、行为模式

最新推荐文章于 2024-05-01 11:40:17 发布
最新推荐文章于 2024-05-01 11:40:17 发布
阅读量292 收藏
点赞数
分类专栏： 设计模式

行为型模式：用来对类或对象怎样交互和怎样分配职责进行描述
1、模板模式
在抽象类中统一操作步骤，并规定好接口，让子类实现接口，这样可以把各个具体的子类和操作步骤解耦合
这里写图片描述


#include <iostream>
using namespace std;


class MakeCar
{
public:
    virtual void MakeHead() = 0;
    virtual void MakeBody() = 0;
    virtual void MakeTail() = 0;

public:
    void Make() //模板函数 把业务逻辑给做好
    {
        MakeTail();
        MakeBody();
        MakeHead();
    }
};

//
class Jeep : public MakeCar
{
public:
    virtual void MakeHead()
    {
        cout << "jeep head" << endl;
    }

    virtual void MakeBody()
    {
        cout << "jeep body" << endl;
    }

    virtual void MakeTail()
    {
        cout << "jeep tail" << endl;
    }
};

class Bus : public MakeCar
{
public:
    virtual void MakeHead()
    {
        cout << "Bus head" << endl;
    }

    virtual void MakeBody()
    {
        cout << "Bus body" << endl;
    }

    virtual void MakeTail()
    {
        cout << "Bus tail" << endl;
    }
};

void main()
{
    MakeCar *car = new Bus;
    car->Make();
    delete car;

    MakeCar *car2 = new Jeep;
    car2->Make();
    delete car2;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

2、命令模式
Command模式也叫命令模式 ，是行为设计模式的一种。Command模式通过被称为
Command的类封装了对目标对象的调用行为以及调用参数。
在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。
但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。
这里写图片描述
适用于：
是将一个请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。 


#include <iostream>
using namespace std;

class Doctor
{
public:
    void treat_eye()
    {
        cout << "医生 治疗 眼科病" << endl;
    }

    void treat_nose()
    {
        cout << "医生 治疗 鼻科病" << endl;
    }
};


class CommandTreatEye
{
public:
    CommandTreatEye(Doctor *doctor)
    {
        m_doctor = doctor;
    }
    void treat()
    {
        m_doctor->treat_eye();
    }
private:
    Doctor *m_doctor;
};


class CommandTreatNose
{
public:
    CommandTreatNose(Doctor *doctor)
    {
        m_doctor = doctor;
    }
    void treat()
    {
        m_doctor->treat_nose();
    }
private:
    Doctor *m_doctor;
};



void main21_1()
{
    //1 医生直接看病
    /*
    Doctor *doctor = new Doctor ;
    doctor->treat_eye();
    delete doctor;
    */

    //2 通过一个命令 医生通过 命令 治疗 治病
    Doctor *doctor = new Doctor ;
    CommandTreatEye * commandtreateye = new CommandTreatEye(doctor); //shift +u //转小写 shift+ctl + u转大写
    commandtreateye->treat();
    delete commandtreateye;
    delete doctor;
    return ;
}


void main()
{
    main21_1();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

#include <iostream>
using namespace std;
#include "list"

class Doctor
{
public:
    void treat_eye()
    {
        cout << "医生 治疗 眼科病" << endl;
    }

    void treat_nose()
    {
        cout << "医生 治疗 鼻科病" << endl;
    }
};

class Command
{
public:
    virtual void treat() = 0;
};
class CommandTreatEye : public Command
{
public:
    CommandTreatEye(Doctor *doctor)
    {
        m_doctor = doctor;
    }
    void treat()
    {
        m_doctor->treat_eye();
    }
private:
    Doctor *m_doctor;
};


class CommandTreatNose : public Command
{
public:
    CommandTreatNose(Doctor *doctor)
    {
        m_doctor = doctor;
    }
    void treat()
    {
        m_doctor->treat_nose();
    }
private:
    Doctor *m_doctor;
};


class BeautyNurse
{
public:
    BeautyNurse(Command *command)
    {
        this->command = command;
    }
public:
    void SubmittedCase() //提交病例 下单命令
    {
        command->treat();
    }
protected:
private:
    Command *command;
};

//护士长
class HeadNurse 
{
public:
    HeadNurse()
    {
        m_list.clear();
    }

public:
    void setCommand(Command *command)
    {
        m_list.push_back(command);
    }
    void SubmittedCase() //提交病例 下单命令
    {
        for (list<Command *>::iterator it=m_list.begin(); it!=m_list.end(); it++)
        {
            (*it)->treat();
        }
    }
private:
    list<Command *> m_list;
};



void main21_1()
{
    //1 医生直接看病
    /*
    Doctor *doctor = new Doctor ;
    doctor->treat_eye();
    delete doctor;
    */

    //2 通过一个命令 医生通过 命令 治疗 治病
    Doctor *doctor = new Doctor ;
    Command * command = new CommandTreatEye(doctor); //shift +u //转小写 shift+ctl + u转大写
    command->treat();
    delete command;
    delete doctor;
    return ;
}


void main21_2()
{
    //3 护士提交简历 给以上看病
    BeautyNurse     *beautynurse = NULL;
    Doctor          *doctor = NULL;
    Command         *command  = NULL;

    doctor = new Doctor ;

    //command = new CommandTreatEye(doctor); //shift +u //转小写 shift+ctl + u转大写
    command = new CommandTreatNose(doctor); //shift +u //转小写 shift+ctl + u转大写
    beautynurse = new BeautyNurse(command);
    beautynurse->SubmittedCase();

    delete doctor;
    delete command;
    delete beautynurse;
    return ;
}


//4 通过护士长 批量的下单命令
void main21_3()
{
    //护士提交简历 给以上看病
    HeadNurse       *headnurse = NULL;
    Doctor          *doctor = NULL;
    Command         *command1  = NULL;
    Command         *command2  = NULL;

    doctor = new Doctor ;

    command1 = new CommandTreatEye(doctor); //shift +u //转小写 shift+ctl + u转大写
    command2 = new CommandTreatNose(doctor); //shift +u //转小写 shift+ctl + u转大写

    headnurse = new HeadNurse(); //new 护士长
    headnurse->setCommand(command1);
    headnurse->setCommand(command2);

    headnurse->SubmittedCase(); // 护士长 批量下单命令

    delete doctor;
    delete command1;
    delete command2;
    delete headnurse;
    return ;
}


void main()
{
    //main21_1();
    //main21_2();
    main21_3();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3 、责任链模式
这里写图片描述


#include <iostream>
using namespace std;

/*
struct Teacher
{
    char name;
    int age;
    Teacher *next;
};
*/

//造完车 以后,需要把任务 传递下去
class CarHandle
{
public:
    virtual void HandleCar() = 0;
    CarHandle *setNextHandle(CarHandle *handle)
    {
        m_handle = handle;
        return m_handle;
    }

protected:
    CarHandle *m_handle;  //下一个处理单元
};

class HeadCarHandle : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造车头" << endl;
        //造 玩车头 以后 把任务递交给 下一个处理者
        if (m_handle != NULL) 
        {
            m_handle->HandleCar(); //
        }
    }
};

class BodyCarHandle : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造 车身" << endl;
        //造 造 车身 以后 把任务递交给 下一个处理者
        if (m_handle != NULL) 
        {
            m_handle->HandleCar(); //
        }

    }
};

class TailCarHandle : public CarHandle
{
public:
    virtual void HandleCar()
    {
        cout << "造车尾" << endl;
        //造 造车尾 以后 把任务递交给 下一个处理者
        if (m_handle != NULL) 
        {
            m_handle->HandleCar(); //
        }
    }
};


void main()
{
    CarHandle *headHandle = new HeadCarHandle;
    CarHandle *bodyHandle = new BodyCarHandle;
    CarHandle *tailHandle = new TailCarHandle;

    //任务的处理关系
    /*
    headHandle->setNextHandle(bodyHandle);
    bodyHandle->setNextHandle(tailHandle);
    tailHandle->setNextHandle(NULL);
    */


    headHandle->setNextHandle(tailHandle);
    tailHandle->setNextHandle(bodyHandle);
    bodyHandle->setNextHandle(NULL);

    headHandle->HandleCar();

    /*
    //业务逻辑 写死在客户端了..
    headHandle->HandleCar();
    bodyHandle->HandleCar();
    tailHandle->HandleCar();
    */

    delete headHandle;
    delete bodyHandle;
    delete tailHandle;

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

4、策略模式
这里写图片描述
Strategy:
策略（算法）抽象。
ConcreteStrategy
各种策略（算法）的具体实现。
Context
策略的外部封装类，或者说策略的容器类。根据不同策略执行不同的行为。策略由外部环境决定。
适用于：
准备一组算法，并将每一个算法封装起来，使得它们可以互换。


#include <iostream>
using namespace std;


class Strategy
{
public:
    virtual void crypt() = 0;
};

//对称加密  速度快 加密大数据块文件 特点:加密密钥和解密密钥是一样的.
//非对称加密 加密速度慢 加密强度高 高安全性高 ;特点: 加密密钥和解密密钥不一样  密钥对(公钥 和 私钥)
//


class AES :  public Strategy
{
public:
    virtual void crypt()
    {
        cout << "AES加密算法" << endl;
    }
};
class DES :  public Strategy
{
public:
    virtual void crypt()
    {
        cout << "DES 加密算法" << endl;
    }
};


class Context
{
public:
    void setStrategy(Strategy *strategy)
    {
        this->strategy = strategy;
    }
    void myoperator()
    {
        strategy->crypt();
    }

protected:
private:
    Strategy *strategy;
};


void main()
{
    /*
    //1 
    DES *des = new DES;
    des->crypt();
    delete des;
    */

    Strategy *strategy = NULL;

    //strategy = new DES;
    strategy = new AES;
    Context *context = new Context;
    context->setStrategy(strategy);
    context->myoperator();

    delete  strategy;
    delete  context;

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

5、中介模式
适用于：
用一个中介对象，封装一些列对象（同事）的交换，中介者是各个对象不需要显示的相互作用，从而实现了耦合松散，而且可以独立的改变他们之间的交换。
这里写图片描述



#include <iostream>
using namespace std;
#include "string"



class Mediator;

class Person
{
public:
    Person(string name, int sex, int condi, Mediator *m)
    {
        m_name = name;
        m_sex = sex;
        m_condi = condi;
        mediator = m;
    }
    string getName()
    {
        return m_name;
    }
    int getSex()
    {
        return m_sex;
    }
    int getCondi()
    {
        return m_condi;
    }
    virtual void getParter(Person *p) = 0;

protected:
    string  m_name;
    int     m_sex;
    int     m_condi;
     Mediator *mediator;
};


class Mediator
{
public:
    void setMan(Person *man)
    {
        pMan = man;
    }
    void setWoman(Person *woman)
    {
        pWoman = woman;
    }

public:
    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:
private:
    Person  *pMan; 
    //list<Person *> m_list;
    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)
    {
        mediator->setMan(p);
        mediator->setWoman(this);
        mediator->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)
    {
        mediator->setMan(this);
        mediator->setWoman(p);
        mediator->getParter(); //找对象 
    }
};

void main()
{
    //string name, int sex, int condi
    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);

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

6、观察者模式
一对多的关系，一个改变通知所有的
被观察者持有观察者的引用，当被观察者发生变化，notify所有观察者
适用于：
定义对象间一种一对多的依赖关系，使得每一个对象改变状态，则所有依赖于他们的对象都会得到通知。

这里写图片描述


#include <iostream>
using namespace std;
#include "string"
#include "list"


class Secretary;


//观察者 
class PlayserObserver
{
public:
    PlayserObserver(Secretary *secretary)
    {
        this->m_secretary = secretary;
    }
    void update(string action)
    {
        cout << "action:" << action << endl;
        cout << "老板来了 我很害怕啊..." << endl;

    }
private:
    Secretary *m_secretary;
};
//
class Secretary
{
public:
    Secretary()
    {
        m_list.clear();
    }
    void Notify(string info)
    {
        //给所有的 观察者 发送 情报
        for ( list<PlayserObserver *>::iterator it=m_list.begin(); it!=m_list.end(); it++)
        {
            (*it)->update(info); //
        }
    }

    void setPlayserObserver(PlayserObserver *o)
    {
        m_list.push_back(o);
    }

private:
    list<PlayserObserver *> m_list;
};
void main()
{
    Secretary           *secretary = NULL;
    PlayserObserver     *po1 = NULL;
    PlayserObserver     *po2 = NULL;

    secretary = new Secretary;
    po1 = new PlayserObserver(secretary);
    po2 = new PlayserObserver(secretary);

    secretary->setPlayserObserver(po1);
    secretary->setPlayserObserver(po2);

    secretary->Notify("老板来了") ;
    secretary->Notify("老板走了");
    delete secretary ;
    delete po1 ;
    delete po2 ;

    system("pause");
    return ;
}

7、备忘录模式
是保存对象的内部状态，并在需要的时候（undo/rollback）恢复对象以前的状态。

这里写图片描述
Originator（原生者）
需要被保存状态以便恢复的那个对象。
Memento（备忘录）
该对象由Originator创建，主要用来保存Originator的内部状态。
Caretaker（管理者）
负责在适当的时间保存/恢复Originator对象的状态。
适用于：
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将以后的对象状态恢复到先前保存的状态。
适用于功能比较复杂的，但需要记录或维护属性历史的类；或者需要保存的属性只是众多属性中的一小部分时Originator可以根据保存的Memo还原到前一状态。


#include <iostream>
using namespace std;
#include "string"

//Caretaker 管理者
// MememTo  备忘录

class MememTo
{
public:
    MememTo(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;
    }
    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;
    }

    //保存
    MememTo* createMememTo()
    {
        return new MememTo(m_name, m_age);
    }
    //还原 
    void setMememTo(MememTo* memto)
    {
        this->m_age = memto->getAge();
        this->m_name = memto->getName();
    }
public:
    void printT()
    {
        cout << "m_name:" << m_name << " m_age:" << m_age << endl;
    }
private:
    string  m_name;
    int     m_age;
};

class Caretaker
{
public:
    Caretaker(MememTo *memto)
    {
        this->memto = memto;
    }
    MememTo *getMememTo()
    {
        return memto;
    }
    void setMememTo(MememTo *memto)
    {
        this->memto = memto;
    }
protected:
private:
    MememTo *memto;
};

void main26_02()
{
    //MememTo *memto = NULL;
    Caretaker *caretaker = NULL;
    Person *p = new Person("张三", 32);
    p->printT();

    //创建 Person对象的一个状态
    printf("---------\n");
    caretaker = new Caretaker( p->createMememTo());
    p->setAge(42);
    p->printT();

    printf("还原旧的状态\n" );
    p->setMememTo(caretaker->getMememTo());
    p->printT();

    delete caretaker;
    delete p;
}

void main26_01()
{
    MememTo *memto = NULL;
    Person *p = new Person("张三", 32);
    p->printT();

    //创建 Person对象的一个状态
    printf("---------\n");
    memto = p->createMememTo();
    p->setAge(42);
    p->printT();

    printf("还原旧的状态\n" );
    p->setMememTo(memto);
    p->printT();

    delete memto;
    delete p;
}
void main()
{
    //main26_01();
    main26_02();
    system("pause");
    return ;
}

8、访问者模式

不同的动作访问不同的数据结构；
这里写图片描述

比如有一个公园，有一到多个不同的组成部分；该公园存在多个访问者：清洁工A负责打扫公园的A部分，清洁工B负责打扫公园的B部分，公园的管理者负责检点各项事务是否完成，上级领导可以视察公园等等。也就是说，对于同一个公园，不同的访问者有不同的行为操作，而且访问者的种类也可能需要根据时间的推移而变化（行为的扩展性）。
适用于：
把数据结构 和 作用于数据结构上的操作 进行解耦合;
适用于数据结构比较稳定的场合
访问者模式总结：
访问者模式优点是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
那访问者模式的缺点是是增加新的数据结构变得困难了


#include <iostream>
using namespace std;
#include "list"

// Visitor  ParkElement

class ParkElement;

class Visitor
{
public:
    virtual void visit(ParkElement *parkelement) = 0;
};

class ParkElement
{
public:
    virtual void accept(Visitor *visit) = 0;
};

class  ParkA : public ParkElement
{
public:
    virtual void accept(Visitor *v)
    {
        v->visit(this); //公园接受访问者访问 让访问者做操作
    }
};


class  ParkB : public ParkElement
{
public:
    virtual void accept(Visitor *v)
    {
        v->visit(this); //公园接受访问者访问 让访问者做操作
    }

};

//整个公园 
class Park : public ParkElement
{
public:
    Park()
    {
        m_list.clear();
    }
    void setParkElement(ParkElement *pe)
    {
        m_list.push_back(pe);
    }

public:
    virtual void accept(Visitor *v)
    {
        //v->visit(this); //公园接受访问者访问 让访问者做操作

        for (list<ParkElement *>::iterator it = m_list.begin(); it!=m_list.end(); it++ )
        {
            (*it)->accept(v);  //公园A 公园B 接受 管理者v访问
        }
    }

private:
    list<ParkElement *> m_list; //公园的每一部分  //应该让公园的每一个部分 都让 管理者访问
};

class VisitorA : public Visitor
{
public:
    virtual void visit(ParkElement *parkelement)
    {
        cout << "清洁工A 完成 公园A部分的 打扫 " << endl; //parkelement->getName();
    }
};

class VisitorB : public Visitor
{
public:
    virtual void visit(ParkElement *parkelement)
    {
        cout << "清洁工B 完成 公园B部分的 打扫 " << endl; //parkelement->getName();
    }
};

class ManagerVisitor : public Visitor

{
public:
    virtual void visit(ParkElement *parkelement)
    {
        cout << "管理者 访问公园 的 各个部分 " << endl; //parkelement->getName();
    }
};

void main27_01()
{
    Visitor *vA = new  VisitorA;
    Visitor *vB = new  VisitorB;

    ParkA *parkA = new ParkA;
    ParkB *parkB = new ParkB;

    //
    parkA->accept(vA);
    parkB->accept(vB);

    delete vA;
    delete vB;
    delete parkA;
    delete parkB;
}

void main27_02()
{
    Visitor *vManager = new  ManagerVisitor ;
    Park *park = new Park;

    ParkElement *parkA = new ParkA;
    ParkElement *parkB = new ParkB;

    park->setParkElement(parkA);
    park->setParkElement(parkB);

    //整个公园 接受 管理者访问
    park->accept(vManager);

    delete parkA;
    delete parkB;
    delete park;
    delete vManager;
}

void main()
{
    //main27_01();
    main27_02();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

9、状态模式
通过用户的状态来改变对象的行为
这里写图片描述


#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) //改变状态 7 
    {
        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;
}

void main()
{
    Worker *w1 = new Worker;
    w1->setHour(7);
    w1->doSomeThing();

    w1->setHour(9);
    w1->doSomeThing();

    delete w1;
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

解释模式
这里写图片描述


#include <iostream>
using namespace std;

// Context 

// Expression 

// PlusExpression   MinusExpression 

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  interpreter(Context *context) = 0;
private:
    Context     *m_context;
};


//╝Мие
class PlusExpression : public Expression
{
public:
    PlusExpression()
    {
        this->context = NULL;
    }
    virtual void  interpreter(Context *context)
    {
        int num = context->getNum();
        num ++;
        context->setNum(num);
        context->setRes(num);
    }
private:
    Context *context;
};


// ╝ш ие
class MinusExpression : public Expression
{
public:
    MinusExpression()
    {
        this->context = NULL;
    }
    virtual void  interpreter(Context *context)
    {
        int num = context->getNum();
        num -- ;
        context->setNum(num);
        context->setRes(num);
    }
private:
    Context *context;
};



void main()
{

    Expression      *expression = NULL;
    Context         *context = NULL;

    Expression      *expression2 = NULL;

    context = new Context(10);
    cout << context->getNum() << endl;

    expression = new PlusExpression;
    expression->interpreter(context);

    cout << context->getRes() << endl;

    //////////////////////////////////////////////////////////////////////////
    expression2 = new MinusExpression;
    expression2->interpreter(context);
    cout << context->getRes() << endl;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

迭代器模式
在迭代器中 持有 一个集合的 引用；所以通过迭代器，就可以访问集合
这里写图片描述


#include <iostream>
using namespace std;

// MyIterator  Aggregate ContreteIterator ConcreteAggregate

//  a    b  c   d
//      ▲


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

class Aggregate
{
public:
    virtual MyIterator *CreateIterator() = 0;
    virtual Object getItem(int index) = 0;
    virtual int getSize() = 0;
};

class ContreteIterator : public MyIterator
{
public:
    ContreteIterator(Aggregate *ag)
    {
        _ag = ag;
        _current_index = 0;
    }
    virtual void First()
    {
        _current_index = 0;  //让当前 游标 回到位置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);
    }
protected:
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 *CreateIterator()
    {
        return new ContreteIterator(this); //让迭代器 持有一个 集合的 引用 
    }
    virtual Object getItem(int index)
    {
        return object[index];
    }
    virtual int getSize()
    {
        return SIZE;
    }
private:
    Object object[SIZE]; 
};

void main()
{
    Aggregate * ag = new ConcreteAggregate;

    MyIterator *it = ag->CreateIterator();

    for (; !(it->IsDone()); it->Next() )
    {
        cout << it->CurrentItem() << " ";
    }

    delete it;
    delete ag;

    system("pause");
    return ;
}
沉城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 行为模式 状态模式 封装数据的状态流转逻辑
lm324114的专栏
12-16 3489
转载地址https://www.cnblogs.com/chenssy/p/3280212.html 介绍状态模式之前，我们先来看这样一个实例：你公司力排万难终于获得某个酒店的系统开发项目，并且最终落到了你的头上。下图是他们系统的主要工作(够简单)。 当你第一眼看到这个系统的时候你就看出来了这是一个状态图，每个框框都代表了房间的状态，箭头表示房间状态的转换。分析如
设计模式之行为型模式代码.zip
12-29
5. **模板方法模式**： 模板方法模式定义了一个操作中的算法骨架，而将一些步骤延迟到子类中。它使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。在框架开发中，模板方法常用来定义基础流程，...
行为型模式：命令模式
weixin_34124651的博客
02-22 109
LieBrother原文：行为型模式：命令模式 十一大行为型模式之三：命令模式。 简介 姓名 ：命令模式 英文名 ：Command Pattern 价值观 ：军令如山 个人介绍 ： Encapsulate a request as an object,thereby letting you parameterize clients wi...
行为型模式
奔走的蚂蚁的博客
05-01 1069
行为型模式特别关注对象之间的通信包括1、 责任链模式（ChainofResponsibilityPattern）；2、 命令模式（CommandPattern）；3、 解释器模式（InterpreterPattern）；4、 迭代器模式（IteratorPattern）；5、 中介者模式（MediatorPattern）；6、 备忘录模式（MementoPattern）；7、 观察者模式（ObserverPattern）；8、 状态模式（StatePattern）；
行为模式
zhiquan的专栏
06-10 1028
行为模式：         行为模式涉及到算法和对象间职责的分配。行为模式不仅描述对象和类得模式，还描述它们之间的通信模式。这些模式刻画了在运行时难以跟踪的复杂的控制流。他们将你的注意力从控制流转移到对象间的联系方式上来。    Chain of responsibility 职责链 ----- 对象行为型模式作用：使多个对象都有
【设计模式】命令模式
weixin_34268843的博客
06-19 220
命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。 介绍 意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。 主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为...
设计模式之行为型模式
yangzhiyong77
11-07 158
行为型模式描述类或对象如何交互及如何分配职责，它主要涉及通过合理的处理方法，达到使系统升级性和维护性提高的目的。 行为模式 1.职责链模式 Chain of Responsibility 2.命令模式 Command 3.解释器模式 Interpreter 4.迭代器模式 Iterator 5.中介者模式 Mediator 6.备忘录...
设计模式_行为模式
07-31
在这个“设计模式_行为模式”主题中，我们将深入探讨几种关键的行为模式。 1. 责任链模式（Chain of Responsibility）：此模式允许创建一个处理请求的对象链，每个对象都可以处理请求或将其传递给链中的下一个对象...
23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种
12-22
设计模式分为三大类：创建型模式、结构型模式和行为型模式。 **创建型模式**关注的是对象的创建。共有五种创建型模式： 1. **工厂方法模式**：它定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法...
C#面向对象设计模式纵横谈-行为模式（合集）
10-14
"C#面向对象设计模式纵横谈-行为模式（合集）"由李建忠老师主讲，深入探讨了在C#中如何运用行为型设计模式来优化软件结构和提高代码的可读性、可维护性。 行为型设计模式主要关注对象之间的责任分配和交互，它们...
基于 YOLOv5 的行为识别
最新发布
05-18
这些轨迹可以反映人物的行为模式，如移动路径、动作顺序等。 3. 分类与识别：利用深度学习模型（如LSTM、GRU等）对连续帧的特征进行建模，以捕捉行为的动态变化。通过比较不同行为的模型相似度，可以实现行为分类。...
行为模式（观察者模式）
Again yy
05-08 317
观察者模式，也称发布-订阅模式，定义了一个被观察者和多个观察者的、一对多的对象关系。 在被观察者状态发生变化的时候，它的所有观察者都会收到通知，并自动更新。 观察者模式通常用在实时事件处理系统、组件间解耦、数据库驱动的消息队列系统，同时也是MVC设计模式中的重要组成部分。 以下我们以订单创建为例。 当订单创建后，系统会发送邮件和短信，并保存日志记录。 1 问题 在没有用观察者模式的时候...
行为型模式——策略模式（Strategy）
有道无术，术尚可求，有术无道，止于术。
05-28 3747
开头     随着设计模式的学习，我们来到了最后一个模式——那就是行为型模式，前面我们讲了创建型模式，他是描述如何更好的创建对象，后来我们学习了结构型模式，它讲了如何更好的描述类与类之间更好的组合，那么今天我们学习的行为模式是描述类与类之间如何更好的分配职责和交互。三者之间层层递进，环环相扣。那么我们今天就拿行为模式中最简单的一个模式——策略模式。看看策略模式是如何完成类与类之间交互的？内容   ...
行为模式简介
iteye_3355的博客
03-18 196
        行为模式是对在不同的对象之间划分责任和算法的抽象化，行为模式不仅仅是关于类和对象的，而且是关于他们之间的相互作用的。        行为模式分类类的行为模式和对象的行为模式两种        1）类的行为模式                   类的行为模式使用继承关系在几个类之间分配行为         2）对象的行为模式                  对象的行为...
c++之行为模式
qq_46615150的博客
02-04 441
行为型模式 行为模式：关注系统中对象之间的相互交互，研究运行时对象之间的相互通信和协作，明确对象职责 1. 观察者模式 模式动机：建立一套低耦合的消息触发机制。 建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。 2 观察者模式概述 观察者模式是使用频率最高的设计
设计模式之行为模式
qq_42292373的博客
08-19 1565
文章目录一、策略模式二、模板方法模式三、观察者模式 创建型模式（5个） 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 （记忆：抽象想象的方法，建造一个原来单一的工厂） 结构型模式（7个） 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式 行为模式（11个） 策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 所有的设计模式都是为了程序能更好的满足这六大原则。设计模式一共有 23 种，今天我们
[设计模式- 行为模式(11种)-01观察者模式]
m0_61164038的博客
02-12 473
[设计模式- 行为模式(11种)-01观察者模式]
"设计模式原理与应用：行为模式简介与应用实例
其中，行为模式是设计模式中的一种重要分类，它描述了对象之间的通信方式和责任分配方式。 1. Chain of Responsibility（职责链）模式： Chain of Responsibility模式通过将多个对象连接成一条链，依次传递请求直到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值