目录
行为型模式
行为型模式主要包括：模板模式、命令模式、责任链模式、策略模式、中介模式、观察者模式、备忘录模式、访问者模式、状态模式、解释模式、迭代器模式。
模板模式
Abstract
Template Method模式也叫模板方法模式，是行为模式之一，它把具有特定步骤算法中的某些必要的处理委让给抽象方法，通过子类继承对抽象方法的不同实现改变整个算法的行为。
Role
AbstractClass：
抽象类的父类
ConcreteClass：
具体的实现子类
templateMethod()：
模板方法
method1()与method2()：
具体步骤方法
Demo
#include <iostream>
using namespace std;
class MakeCar
{
public:
virtual void makeHead() = 0;
virtual void makeBody() = 0;
virtual void makeTail() = 0;
public: //把一组行为 变成 一个模板
void make()
{
makeHead();
makeBody();
makeTail();
}
protected:
private:
};
class MakeBus : public MakeCar
{
public:
virtual void makeHead()
{
cout << "bus 组装 车头" << endl;
}
virtual void makeBody()
{
cout << "bus 组装 车身" << endl;
}
virtual void makeTail()
{
cout << "bus 组装 车尾" << endl;
}
protected:
private:
};
class MakeJeep : public MakeCar
{
public:
virtual void makeHead()
{
cout << "Jeep 组装 车头" << endl;
}
virtual void makeBody()
{
cout << "Jeep 组装 车身" << endl;
}
virtual void makeTail()
{
cout << "Jeep 组装 车尾" << endl;
}
protected:
private:
};
void main()
{
MakeCar *bus = new MakeBus;
//bus->makeHead();
//bus->makeBody();
//bus->makeTail();
bus->make();
MakeCar *jeep = new MakeJeep;
//jeep->makeHead();
//jeep->makeBody();
//jeep->makeTail();
jeep->make();
delete bus;
delete jeep;
cout<<"hello..."<<endl;
system("pause");
return ;
}
命令模式
abstract
Command模式也叫命令模式，是行为设计模式的一种。Command模式通过被称为
Command的类封装了对目标对象的调用行为以及调用参数。
在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。
但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。
整个调用过程比较繁杂，或者存在多处这种调用。这时，使用Command类对该调用加以封装，便于功能的再利用。-
调用前后需要对调用参数进行某些处理。调用前后需要进行某些额外处理，比如日志，缓存，记录历史操作等。
Role
Command
Command命令的抽象类。
ConcreteCommand
Command的具体实现类。
Receiver
需要被调用的目标对象。
Invorker
通过Invorker执行Command对象。
适用于：
是将一个请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
Demo
#include <iostream>
using namespace std;
#include "list"
class Vendor
{
public:
void sailbanana()
{
cout << "卖香蕉" << endl;
}
void sailapple()
{
cout << "卖苹果" << endl;
}
};
class Command
{
public:
virtual void sail() = 0;
};
class BananaCommand : public Command
{
public:
BananaCommand(Vendor *v)
{
m_v = v;
}
Vendor *getV(Vendor *v)
{
return m_v;
}
void setV(Vendor *v)
{
m_v = v;
}
virtual void sail()
{
m_v->sailbanana();
}
protected:
private:
Vendor *m_v;
};
class AppleCommand : public Command
{
public:
AppleCommand(Vendor *v)
{
m_v = v;
}
Vendor *getV(Vendor *v)
{
return m_v;
}
void setV(Vendor *v)
{
m_v = v;
}
virtual void sail()
{
m_v->sailapple();
}
protected:
private:
Vendor *m_v;
};
class Waiter
{
public:
Command *getCommand()
{
return m_command;
}
void setCommand(Command *c)
{
m_command = c;
}
void sail()
{
m_command->sail();
}
protected:
private:
Command *m_command;
};
class AdvWaiter
{
public:
AdvWaiter()
{
m_list = new list<Command *>;
m_list->resize(0);
}
~AdvWaiter()
{
delete m_list;
}
void setCommands(Command *c)
{
m_list->push_back(c);
}
list<Command *> * getCommands()
{
return m_list;
}
void sail()
{
for (list<Command *>::iterator it=m_list->begin(); it!=m_list->end(); it++ )
{
(*it)->sail();
}
}
protected:
private:
list<Command *> *m_list;
};
//小商贩 直接 卖 水果
void main25_01()
{
Vendor *v = new Vendor;
v->sailapple();
v->sailbanana();
delete v;
return ;
}
//小商贩 通过命令 卖 水果
void main25_02()
{
Vendor *v = new Vendor;
AppleCommand *ac = new AppleCommand(v);
ac->sail();
BananaCommand *bc = new BananaCommand(v);
bc->sail();
delete bc;
delete ac;
delete v;
}
//小商贩 通过waiter 卖 水果
void main25_03()
{
Vendor *v = new Vendor;
AppleCommand *ac = new AppleCommand(v);
BananaCommand *bc = new BananaCommand(v);
Waiter *w = new Waiter;
w->setCommand(ac);
w->sail();
w->setCommand(bc);
w->sail();
delete w;
delete bc;
delete ac;
delete v;
}
//小商贩 通过advwaiter 批量下单 卖水果
void main25_04()
{
Vendor *v = new Vendor;
AppleCommand *ac = new AppleCommand(v);
BananaCommand *bc = new BananaCommand(v);
AdvWaiter *w = new AdvWaiter;
w->setCommands(ac);
w->setCommands(bc);
w->sail();
delete w;
delete bc;
delete ac;
delete v;
}
void main()
{
//main25_01();
//main25_02();
//main25_03();
main25_04();
system("pause");
}责任链模式
abstract
Chain of Responsibility（CoR）模式也叫职责链模式或者职责连锁模式，是行为模式之一，该模式构造一系列分别担当不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以被称作职责链模式。
例1：比如客户Client要完成一个任务，这个任务包括a,b,c,d四个部分。
首先客户Client把任务交给A，A完成a部分之后，把任务交给B，B完成b部分，...，直到D完成d部分。
例2：比如政府部分的某项工作，县政府先完成自己能处理的部分，不能处理的部分交给省政府，省政府再完成自己职责范围内的部分，不能处理的部分交给中央政府，中央政府最后完成该项工作。
例3：软件窗口的消息传播。
例4：SERVLET容器的过滤器（Filter）框架实现。
Role
Handler
处理类的抽象父类。
concreteHandler
具体的处理类。
Demo
#include <iostream>
using namespace std;
class CarHandle
{
public:
virtual void HandleCar() = 0;
public:
CarHandle *setNextHandle(CarHandle *carhandle)
{
this->carhandle = carhandle;
return this->carhandle;
}
protected:
CarHandle *carhandle;
};
class CarHandleHead : public CarHandle
{
public:
virtual void HandleCar()
{
cout << "处理车头" << endl;
if (this->carhandle != NULL)
{
carhandle->HandleCar();
}
}
};
class CarHandleBody : public CarHandle
{
public:
virtual void HandleCar()
{
cout << "处理车身" << endl;
if (this->carhandle != NULL)
{
carhandle->HandleCar();
}
}
};
class CarHandleTail : public CarHandle
{
public:
virtual void HandleCar()
{
cout << "处理车尾" << endl;
if (this->carhandle != NULL)
{
carhandle->HandleCar();
}
}
};
void main()
{
CarHandleHead *head = new CarHandleHead;
CarHandleBody *body = new CarHandleBody;
CarHandleTail *tail = new CarHandleTail;
head->setNextHandle(body);
body->setNextHandle(tail);
tail->setNextHandle(NULL);
//处理
head->HandleCar();
delete head;
delete body;
delete tail;
system("pause");
return ;
}
策略模式
Abstract
Strategy模式也叫策略模式是行为模式之一，它对一系列的算法加以封装，为所有算法定义一个抽象的算法接口，并通过继承该抽象算法接口对所有的算法加以封装和实现，具体的算法选择交由客户端决定（策略）。Strategy模式主要用来平滑地处理算法的切换。
Role
trategy:
策略（算法）抽象。
ConcreteStrategy
各种策略（算法）的具体实现。
Context
策略的外部封装类，或者说策略的容器类。根据不同策略执行不同的行为。策略由外部环境决定。
Demo
//Symmetric encryption
class Strategy
{
public:
virtual void SymEncrypt() = 0;
};
class Des : public Strategy
{
public:
virtual void SymEncrypt()
{
cout << "Des 加密" << endl;
}
};
class AES : public Strategy
{
public:
virtual void SymEncrypt()
{
cout << "AES 加密" << endl;
}
};
class Context
{
public:
Context(Strategy *strategy)
{
p = strategy;
}
void Operator()
{
p->SymEncrypt();
}
private:
Strategy *p;
};
//算法的实现 和 客户端的使用 解耦合
//使得算法变化，不会影响客户端
void main()
{
/* 不符合开闭原则
Strategy *strategy = NULL;
strategy = new AES;
strategy->SymEncrypt();
delete strategy;
strategy = new Des;
strategy->SymEncrypt();
delete strategy;
*/
Strategy *strategy = NULL;
Context *ctx = NULL;
strategy = new AES;
ctx = new Context(strategy);
ctx->Operator();
delete strategy;
delete ctx;
cout<<"hello..."<<endl;
system("pause");
return ;
}
中介者模式
abstract
Mediator模式也叫中介者模式，是由GoF提出的23种软件设计模式的一种。Mediator模式是行为模式之一，在Mediator模式中，类之间的交互行为被统一放在Mediator的对象中，对象通过Mediator对象同其他对象交互，Mediator对象起着控制器的作用。
中介就像是我们日常生活中的中介一样，中介掌握着最多的关系连接和资源，负责调配连接，这样可以减少非常多无效的连接。
Role
Mediator抽象中介者
中介者类的抽象父类。
concreteMediator
具体的中介者类。
Colleague
关联类的抽象父类。
concreteColleague
具体的关联类。
适用于：
用一个中介对象，封装一些列对象（同事）的交换，中介者是各个对象不需要显示的相互作用，从而实现了耦合松散，而且可以独立的改变他们之间的交换。
Demo
#include <iostream>
using namespace std;
#include "string"
class Person
{
public:
Person(string name, int sex, int condit)
{
m_name = name;
m_sex = sex;
m_condition = condit;
}
string getName()
{
return m_name;
}
int getSex()
{
return m_sex;
}
int getCondit()
{
return m_condition;
}
virtual void getParter(Person *p) = 0;
protected:
string m_name; //
int m_sex; //1男 2女
int m_condition; //123456789;
};
class Man : public Person
{
public:
Man(string name, int sex, int condit):Person(name, sex, condit)
{
;
}
virtual void getParter(Person *p)
{
if (this->getSex() == p->getSex())
{
cout << "No No No 我不是同性恋" << endl;
}
if (this->getCondit() == p->getCondit())
{
cout << this->getName() << " 和 " << p->getName() << "绝配" << endl;
}
else
{
cout << this->getName() << " 和 " << p->getName() << "不配" << endl;
}
}
protected:
};
class Woman : public Person
{
public:
Woman(string name, int sex, int condit):Person(name, sex, condit)
{
;
}
virtual void getParter(Person *p)
{
if (this->getSex() == p->getSex())
{
cout << "No No No 我不是同性恋" << endl;
}
if (this->getCondit() == p->getCondit())
{
cout << this->getName() << " 和 " << p->getName() << "绝配" << endl;
}
else
{
cout << this->getName() << " 和 " << p->getName() << "不配" << endl;
}
}
protected:
};
//以上 Woman Man类的太紧密 需要解耦合
void main1901()
{
Woman *w1 = new Woman("小芳", 2, 4);
Man *m1 = new Man("张三", 1, 3);
Man *m2 = new Man("李四", 1, 4);
w1->getParter(m1);
w1->getParter(m2);
delete w1;
delete m1;
delete m2;
return ;
}
class Mediator ;
class Person2
{
public:
Person2(string name, int sex, int condition, Mediator *m)
{
m_name = name;
m_sex = sex;
m_condition = condition;
m_m = m;
}
string getName()
{
return m_name;
}
int getSex()
{
return m_sex;
}
int getCondit()
{
return m_condition;
}
Mediator *getMediator()
{
return m_m;
}
public:
virtual void getParter(Person2 *p) = 0;
protected:
string m_name; //
int m_sex; //1男 2女
int m_condition; //123456789;
Mediator *m_m;
};
class Mediator
{
public:
Mediator()
{
pMan = NULL;
pWoman = NULL;
}
void setWoman(Person2 *p)
{
pWoman = p;
}
void setMan(Person2 *p)
{
pMan = p;
}
void getPartner()
{
if (pMan->getSex() == pWoman->getSex())
{
cout << "No No No 我不是同性恋" << endl;
}
if (pMan->getCondit() == pWoman->getCondit())
{
cout << pMan->getName() << " 和 " << pWoman->getName() << "绝配" << endl;
}
else
{
cout << pMan->getName() << " 和 " << pWoman->getName() << "不配" << endl;
}
}
protected:
private:
Person2 *pMan;
Person2 *pWoman;
};
class Woman2 : public Person2
{
public:
Woman2(string name, int sex, int condition, Mediator *m) : Person2(name, sex, condition, m)
{
;
}
virtual void getParter(Person2 *p)
{
this->getMediator()->setWoman(this);
this->getMediator()->setMan(p);
this->getMediator()->getPartner();
}
private:
};
class Man2 : public Person2
{
public:
Man2(string name, int sex, int condition, Mediator *m) : Person2(name, sex, condition, m)
{
;
}
virtual void getParter(Person2 *p)
{
this->getMediator()->setMan(this);
this->getMediator()->setWoman(p);
this->getMediator()->getPartner();
}
private:
};
void main1902()
{
Mediator *mediator = new Mediator;
Woman2 *w1 = new Woman2("小芳", 2, 4, mediator);
Man2 *m1 = new Man2("张三", 1, 3, mediator);
Man2 *m2 = new Man2("李四", 1, 4, mediator);
w1->getParter(m1);
w1->getParter(m2);
delete w1;
delete m1;
delete m2;
delete mediator;
}
void main()
{
//main1901(); //问题的引出
main1902(); //用中介者模式 进行优化
system("pause");
}
观察者模式observer
abstract
Observer模式是行为模式之一，它的作用是当一个对象的状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态。
Observer模式提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。
Role
Subject（被观察者）
被观察的对象。当需要被观察的状态发生变化时，需要通知队列中所有观察者对象。Subject需要维持（添加，删除，通知）一个观察者对象的队列列表。
ConcreteSubject
被观察者的具体实现。包含一些基本的属性状态及其他操作。
Observer（观察者）
接口或抽象类。当Subject的状态发生变化时，Observer对象将通过一个callback函数得到通知。
ConcreteObserver
观察者的具体实现。得到通知后将完成一些具体的业务逻辑处理。
Demo
#include <iostream>
using namespace std;
#include "vector"
#include "string"
class Secretary;
//玩游戏的同事类（观察者）
class PlayserObserver
{
public:
PlayserObserver(string name, Secretary *secretary)
{
m_name = name;
m_secretary = secretary;
}
void update(string action)
{
cout << "观察者收到action:" << action << endl;
}
private:
string m_name;
Secretary *m_secretary;
};
//秘书类（主题对象，通知者）
class Secretary
{
public:
void addObserver(PlayserObserver *o)
{
v.push_back(o);
}
void Notify(string action)
{
for (vector<PlayserObserver *>::iterator it= v.begin(); it!=v.end(); it++ )
{
(*it)->update(action);
}
}
void setAction(string action)
{
m_action = action;
Notify(m_action);
}
private:
string m_action;
vector<PlayserObserver *> v;
};
void main()
{
//subject 被观察者
Secretary *s1 = new Secretary;
//具体的观察者 被通知对象
PlayserObserver *po1 = new PlayserObserver("小张", s1);
//PlayserObserver *po2 = new PlayserObserver("小李", s1);
s1->addObserver(po1);
//s1->addObserver(po2);
s1->setAction("老板来了");
s1->setAction("老板走了");
cout<<"hello..."<<endl;
system("pause");
return ;
}
备忘录模式
abstract
Memento模式也叫备忘录模式，是行为模式之一，它的作用是保存对象的内部状态，并在需要的时候（undo/rollback）恢复对象以前的状态。
Role
Originator（原生者）
需要被保存状态以便恢复的那个对象。
Memento（备忘录）
该对象由Originator创建，主要用来保存Originator的内部状态。
Caretaker（管理者）
负责在适当的时间保存/恢复Originator对象的状态。
适用于：
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将以后的对象状态恢复到先前保存的状态。
适用于功能比较复杂的，但需要记录或维护属性历史的类；或者需要保存的属性只是众多属性中的一小部分时Originator可以根据保存的Memo还原到前一状态。
Demo
#include <iostream>
using namespace std;
#include "string"
class MememTo
{
public:
MememTo(string name, int age)
{
this->m_name = name;
this->m_age = age;
}
void setName(string name)
{
this->m_name = name;
}
string getName()
{
return m_name;
}
void setAge(int age)
{
this->m_age = age;
}
int getAge()
{
return m_age;
}
protected:
private:
string m_name;
int m_age;
};
class Person
{
public:
Person(string name, int age)
{
this->m_name = name;
this->m_age = age;
}
void setName(string name)
{
this->m_name = name;
}
string getName()
{
return m_name;
}
void setAge(int age)
{
this->m_age = age;
}
int getAge()
{
return m_age;
}
void printT()
{
cout << "name: " << m_name << "age: " << m_age << endl;
}
public:
//创建备份
MememTo *createMememTo()
{
return new MememTo(m_name, m_age);
}
//恢复备份
void SetMememTo(MememTo *memto)
{
m_name = memto->getName();
m_age = memto->getAge();
}
protected:
private:
string m_name;
int m_age;
};
//管理者
class Caretaker
{
public:
Caretaker(MememTo *mem)
{
this->m_memto = mem;
}
MememTo *getMememTo()
{
return m_memto;
}
void setMememTo(MememTo *mem)
{
this->m_memto = mem;
}
protected:
private:
MememTo *m_memto;
};
void main23_01()
{
Person *p = new Person("张三", 18);
p->printT();
//创建备份
Caretaker *ct = new Caretaker(p->createMememTo());
p->setAge(28);
p->printT();
//恢复信息
p->SetMememTo(ct->getMememTo());
p->printT();
delete p;
delete ct->getMememTo();
return ;
}
void main23_02()
{
Person *p = new Person("张三", 18);
p->printT();
//创建备份
MememTo * membak = p->createMememTo();
p->setAge(28);
p->printT();
//恢复信息
p->SetMememTo(membak);
p->printT();
delete p;
delete membak;
}
访问者模式
abstract
Visitor模式也叫访问者模式，是行为模式之一，它分离对象的数据和行为，使用Visitor模式，可以不修改已有类的情况下，增加新的操作角色和职责。
侧重于访问者的角色，适用于数据结构简单的情况。
Role
抽象访问者（Visitor）角色：声明了一个或者多个访问操作，形成所有的具体元素角色必须实现的接口。
具体访问者（ConcreteVisitor）角色：实现抽象访问者角色所声明的接口，也就是抽象访问者所声明的各个访问操作。
抽象节点（Element）角色：声明一个接受操作，接受一个访问者对象作为一个参量。
具体节点（ConcreteElement）角色：实现了抽象元素所规定的接受操作。
结构对象（ObiectStructure）角色：有如下的一些责任，可以遍历结构中的所有元素；如果需要，提供一个高层次的接口让访问者对象可以访问每一个元素；如果需要，可以设计成一个复合对象或者一个聚集，如列（List）或集合（Set）。
适用于：
把数据结构和作用于数据结构上的操作进行解耦合;
适用于数据结构比较稳定的场合
访问者模式总结：
访问者模式优点是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
那访问者模式的缺点是是增加新的数据结构变得困难了
Demo
/*
案例需求：
比如有一个公园，有一到多个不同的组成部分；
该公园存在多个访问者：清洁工A负责打扫公园的A部分，清洁工B负责打扫公园的B部分，
公园的管理者负责检点各项事务是否完成，上级领导可以视察公园等等。
也就是说，对于同一个公园，不同的访问者有不同的行为操作，
而且访问者的种类也可能需要根据时间的推移而变化（行为的扩展性）。
*/
#include <iostream>
using namespace std;
#include "list"
#include "string"
class ParkElement;
//不同的访问者 访问公园完成不同的动作
class Visitor
{
public:
virtual void visit(ParkElement *park) = 0;
};
class ParkElement //每一个
{
public:
virtual void accept(Visitor *v) = 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 setPart(ParkElement *e)
{
m_list.push_back(e);
}
public:
void accept(Visitor *v)
{
for ( list<ParkElement *>::iterator it=m_list.begin(); it != m_list.end(); it++)
{
(*it)->accept(v);
}
}
private:
list<ParkElement *> m_list;
};
class VisitorA : public Visitor
{
public:
virtual void visit(ParkElement *park)
{
cout << "清洁工A访问公园A部分，打扫卫生完毕" << endl;
}
};
class VisitorB : public Visitor
{
public:
virtual void visit(ParkElement *park)
{
cout << "清洁工B 访问 公园B 部分，打扫卫生完毕" << endl;
}
};
class VisitorManager : public Visitor
{
public:
virtual void visit(ParkElement *park)
{
cout << "管理员 检查整个公园卫生打扫情况" << endl;
}
};
void main()
{
VisitorA *visitorA = new VisitorA;
VisitorB *visitorB = new VisitorB;
ParkA *partA = new ParkA;
ParkB *partB = new ParkB;
//公园接受访问者a访问
partA->accept(visitorA);
partB->accept(visitorB);
VisitorManager *visitorManager = new VisitorManager;
Park * park = new Park;
park->setPart(partA);
park->setPart(partB);
park->accept(visitorManager);
cout<<"hello..."<<endl;
system("pause");
return ;
}
#include <iostream>
using namespace std;
#include "string"
#include "list"
//客户去银行办理业务
//m个客户
//n个柜员
//将要 对象和要处理的操作分开，不同的柜员可以办理不同来访者的业务
class Element;
//访问者访问柜员
class Visitor
{
public:
virtual void visit(Element *element) = 0;
};
//柜员接受客户访问
class Element
{
public:
virtual void accept(Visitor *v) = 0;
virtual string getName() = 0;
};
//柜员A 员工
class EmployeeA : public Element
{
public:
EmployeeA(string name)
{
m_name = name;
}
virtual void accept(Visitor *v)
{
v->visit(this);
}
virtual string getName()
{
return m_name;
}
private:
string m_name;
};
//柜员B 员工
class EmployeeB : public Element
{
public:
EmployeeB(string name)
{
m_name = name;
}
virtual void accept(Visitor *v)
{
v->visit(this);
}
string getName()
{
return m_name;
}
private:
string m_name;
};
class VisitorA : public Visitor
{
public:
virtual void visit(Element *element)
{
cout << "通过" << element->getName() << "做A业务" << endl;
}
};
class VisitorB : public Visitor
{
public:
virtual void visit(Element *element)
{
cout << "通过" << element->getName() << "做B业务" << endl;
}
};
void main26_01()
{
EmployeeA *eA = new EmployeeA("柜员A");
VisitorA *vA = new VisitorA;
VisitorB *vB = new VisitorB;
eA->accept(vA);
eA->accept(vB);
delete eA;
delete vA;
delete vB;
return ;
}
//柜员B 员工
class Employees : public Element
{
public:
Employees()
{
m_list = new list<Element *>;
}
virtual void accept(Visitor *v)
{
for (list<Element *>::iterator it = m_list->begin(); it != m_list->end(); it++ )
{
(*it)->accept(v);
}
}
string getName()
{
return m_name;
}
public:
void addElement(Element *e)
{
m_list->push_back(e);
}
void removeElement(Element *e)
{
m_list->remove(e);
}
private:
list<Element *> *m_list;
string m_name;
};
void main26_02()
{
EmployeeA *eA = new EmployeeA("柜员A");
EmployeeA *eB= new EmployeeA("柜员B");
Employees *es = new Employees;
es->addElement(eA);
es->addElement(eB);
VisitorA *vA = new VisitorA;
VisitorB *vB = new VisitorB;
es->accept(vA);
cout << "-------------" << endl;
es->accept(vB);
delete eA;
delete eB
;
delete vA;
delete vB;
return ;
}
void main()
{
//main26_01();
main26_02();
system("pause");
}
状态模式
abstract
State模式也叫状态模式，是行为设计模式的一种。State模式允许通过改变对象的内部状态而改变对象的行为，这个对象表现得就好像修改了它的类一样。
状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转译到表现不同状态的一系列类当中，可以把复杂的判断逻辑简化。
适用于有限状态自动机FSM
Role
Context：用户对象
拥有一个State类型的成员，以标识对象的当前状态；
State：接口或基类
封装与Context的特定状态相关的行为；
ConcreteState：接口实现类或子类
实现了一个与Context某个状态相关的行为。
适用于：
对象的行为，依赖于它所处的当前状态。行为随状态改变而改变的场景。
适用于：通过用户的状态来改变对象的行为。
Demo
#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;
}
void main()
{
Worker *w1 = new Worker;
w1->setHour(7);
w1->doSomeThing();
w1->setHour(9);
w1->doSomeThing();
delete w1;
cout<<"hello..."<<endl;
system("pause");
return ;
}
解释器模式interpreter
abstract
Role
Context
解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
AbstractExpression
解释器抽象类。
ConcreteExpression
解释器具体实现类。
Demo
#include <iostream>
using namespace std;
#include "string"
class Context
{
public:
Context(int num)
{
m_num = num;
}
public:
void setNum(int num)
{
m_num = num;
}
int getNum()
{
return m_num;
}
void setRes(int res)
{
m_res = res;
}
int getRes()
{
return m_res;
}
private:
int m_num;
int m_res;
};
class Expression
{
public:
virtual void interpreter(Context *context) = 0;
};
class PlusExpression : public Expression
{
public:
virtual void interpreter(Context *context)
{
int num = context->getNum();
num ++ ;
context->setNum(num);
context->setRes(num);
}
};
class MinusExpression : public Expression
{
public:
virtual void interpreter(Context *context)
{
int num = context->getNum();
num -- ;
context->setNum(num);
context->setRes(num);
}
};
void main()
{
Context *pcxt = new Context(10);
Expression *e1 = new PlusExpression;
e1->interpreter(pcxt);
cout << "PlusExpression:" << pcxt->getRes() << endl;
Expression *e2 = new MinusExpression;
e2->interpreter(pcxt);
cout << "MinusExpression:" << pcxt->getRes() << endl;
delete e2;
delete e1;
system("pause");
return ;
}
迭代器模式iterator
abstract
Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
主要解决：不同的方式来遍历整个整合对象。
何时使用：遍历一个聚合对象。
如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。
Role
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;
};
class Aggregate
{
public:
virtual Object getItem(int index) = 0;
virtual MyIterator *CreateIterator() = 0;
virtual int getSize() = 0;
};
class ContreteIterator : public MyIterator
{
public:
ContreteIterator(Aggregate *ag)
{
_ag = ag;
_idx = 0;
}
~ContreteIterator()
{
_ag = NULL;
_idx = 0;
}
virtual void First()
{
_idx = 0;
}
virtual void Next()
{
if (_idx < _ag->getSize())
{
_idx ++;
}
}
virtual bool IsDone()
{
return (_idx == _ag->getSize());
}
virtual Object CurrentItem()
{
return _ag->getItem(_idx);
}
protected:
private:
int _idx;
Aggregate *_ag;
};
class ConcreteAggregate : public Aggregate
{
public:
ConcreteAggregate()
{
for (int i=0; i<SIZE; i++)
{
object[i] = i+1;
}
}
virtual ~ConcreteAggregate()
{
}
virtual Object getItem(int index)
{
return object[index];
}
virtual MyIterator *CreateIterator()
{
return new ContreteIterator(this);
}
virtual int getSize()
{
return SIZE;
}
protected:
private:
Object object[SIZE];
};
void main21()
{
// 创建一个集合
Aggregate *ag = new ConcreteAggregate();
// 创建一个遍历这个集合的 迭代器
MyIterator *it = ag->CreateIterator();
//通过迭代器 遍历 集合
for (; !(it->IsDone()); it->Next() )
{
cout << it->CurrentItem() << " ";
}
//清理相关资源
delete it;
delete ag;
}
void main()
{
main21();
system("pause");
return ;
}
EngPerson
{
Public:
Void dowork1(Car *car)
{
Car. Run();
}
Void dowork2()
{
m_car.run()
}
Private:
Car m_car;
}
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
