文中图并不是真正意义上的类图，里面添加了部分方法的实现，便于理解该模式的程序的实现方式
创建型模式：
1. 工厂模式（Factory）：
Factory根据传入的参数condition生成具体的对象Operation对象。添加新产品Operation时并不影响以前系统代码
Operation* obj=Factory::CreateObject('+');
Obj->GetResult();
2.单例模式：（提供全局访问）
类Singleton时添加：Singleton::_instance=0;
全局调用：Singleton::Instance()->.............
3.建造者模式(Builder)：
当对象Product的创建比较复杂分多个部分，想实现对象的创建与对象的使用分开时，创建具体的的建造对象Builder来实现创建过程，具体创建由Direct来控制创建返回具体对象。
Direct* p=new Direct();
Builder* b1=new ConcreteBuilder1();
Builder* b2=new ConcreteBuilder2();
p->Construct(b1);
p->Construct(b2);
Product* pb1=b1->GetResult();
Product* pb2=b2->GetResult();
pb1->show();
pb2->show();
4.抽象工厂模式（abstactFactory）：(创建一组相互依赖的对象)
创建组策略由AbstractFactory子类对象来实现，相互依赖对象ProductA1、ProductB1
和ProductA2、ProductB2
AbstractFactory* cf1=new AbstractFactoryA();
Cf1->createProductA1();
Cf1->createProductB1();
AbstractFactory* cf2=new AbstractFactoryB();
Cf2->createProductA2();
Cf2->createProductB2();
4.原型模式（prototype）：自身复制自己创造新类
Prototype通过调用自身方法Clone（）复制个新的自己实例p1
Prototype* p=new ConcretePrototype();
Prototype* p1=p->Clone();
构造型模式：
1.组合模式(composite)：(构建递归结构)
TComponent中的Vector存储子类Leaf,通过Operation（）方法遍历实现子类的方法，从而达到组合对象和单个对象的统一使用。（管理类需要提供对子类的管理策略类（add,remove,select等方法））
Leaf* l=new Leaf();
l->Operation();
TComponent* com=new TComposite();
Com->Add(l);
Com->Operation();
Component* ll=com->GetChild(0);
ll->Operation();
2.外观模式(facade)：
为一组接口Subsystem1、Subsystem2接口提供一致性界面Facade,用户在Facade中只用添加相应接口即可使用
Facade* f=new Facade();
f->OperationWrapper();
3.装饰模式(decorator)：（解决继承的深度较深，系统变复杂的问题）
为ConcreteComponent类添加新的职责时，通过Decorator类的子类ConcreteDecorator来添加新的功能AddedBehavior。Decorator与ConcreteComponent拥有共同的父类，Decorator
可以承担Compent的所有子类添加功能的作用。
Component* com=new ConcreteComponent();
Decorator* dec=new ConcreteDecorator(com);
dec->Operation();
4.适配器模式(adapter)：（保持服务一致性）
当对象productD提供了对象Product类系列相同的功能play，但不属于Product类时，创建适配器对象ProductC,在ProductC方法play()中使用对象ProductD来实现play功能。
ProductD* po=new ProductD();
Product* pa=new ProductC(po);
Pa->play();
5.享元模式（Flyweight）：
将类Flyweight的子类，放入FlyweightFactory的数组列表中（这里使用的是GetFlyweight方法），使用者通过GetFlyweight（）方法调用所需要的子类，实现共享。
FlyweightFactory* fc=new FlyweightFactory();
Flyweight* fw1=fc->GetFlyweight("hello");（这里类表中有则返回对象，没有则插入并返回）
Flyweight* fw2=fc->GetFlyweight("world");
Flyweight* fw3=fc->GetFlyweight("hello");
6.代理模式（proxy）：(解决创建开销大的对象问题，创建一个代价较小对象去处理)
通过对象Proxy的方法Request去调用ConcreteSubject对象的Request方法，实现了
逻辑和实现的解耦。
Subject* sub= new ConcreteSubject();
Proxy* p= new Proxy(sub);
p->Request();
7.桥接模式（bridge）：（分离抽象与实现,与代理模式差不多）
新的算法AbstractionImp的增加并不影响他的实现Abstraction
AbstractionImp* imp=new ConcreteAbstractionImpA();
Abstraction* abs=new RefinedAbstraction(imp);
abs->Operation();
行为型模式：
1.状态模式：(分离状态逻辑和动作实现部分)
当事物在不同的状态下有不同的表现ConcreteStateA、ConcreteStateB,当状态需要改变时，
当前状态对象OpChangStateA创建改变后的状态B传入父类的ChangState方法,通过调用State的ChangeState方法来改变Context类中当前状态对象
State* st=new ConcreteStateA();
Context* con=new Context(st);
Con->OpChangState(.....);
Con->_state->play();
2.观察者模式(observer)：
创建观察者ConcreteObserverA和ConcreteObserverB，观察者被注册Arrach到观察对象的通知列表_obvs中，当对象Subject发生改变时，Suject通过Notify依次通知列表中的观察者，观察者更新Update获得最新的属性。
ConcreteSubject* sub=new ConcreteSubject();
Observer* p1=new ConcreteObserverA(sub);
Observer* p2=new ConcreteObserverB(sub);
sub->SetState("old");
sub->Notify();
sub->SetState("new");
sub->Notify();
3.策略模式(strategy)：
策略类的增添修改并不影响，并不影响使用的实体类Content。策略类实体作为参数传入使用的实体类来使用。
Strategy_Object* _op=new StrategyA();
Content* pc=new Content(_op);
Pc->DoAction();
4.模板模式（Template）：(封装算法逻辑)
当应用算法是相同的，可以用AbstractClass提供统一的实现Operation1(),
具体的实现在其子类ConcreteClassA、ConcreteClassB中实现。
AbstractClass* p1=new ConcreteClassA();
AbstractClass* p2=new ConcreteClassB();
P1->TemplateMethos();
P2->TemplateMethod();
5.命令模式（command):
将请求封装在Command中，传入处理对象Action,将Command传入Person的Command的队列中，调用Person的Run()将执行命令行为。
Action* rec=new Action();
Command* cmdA=new CommandA(rec);
Command* cmdB=new CommandB(rec);
Person* pe=new Person();
pe->AddCmd(cmdA);
pe->AddCmd(cmdB);
Pe->Run();
6.访问者模式（visitor）：（分离数据结构和访问者）
增加新的操作时添加新的Visitor子类即可，访问对象Element只需在执行响应操作时在Accept()中传入响应访问者实例，在该方法中实现访问者得方法即可。
Visitor* vis=new ConcreteVistorA();
Element* elm=new ConcreteElementA();
Elm->Accept(vis);
7.备忘录模式（memento）：（捕获并保存一个类的状态，可以恢复保存的状态）
Originator将对象状态通过CreateMemento（）保存在Memento中，当调用RestoreToMemento()方法从Memento中取回刚才保存的状态
Originator* or=new Originator();
or->SetState("old");
or->PrintState();
Memento* mo=or->CreateMemento();
or->SetState("new");
or->PrintState();
or->RestoreToMemento(mo);
or->PrintState();
8.中介者模式（mediator）：（处理对象之间交互和通信）
对象ColleageA和ColleageB通信交互时通过ConcreteMediator提供的方法来实现，交互对象不用维护对各自的引用，甚至可以不知道对方的存在，两者只需保存一个Mediator即可实现通信。Mediator保存着通信双方对象，DoActionFromAtoB（）等来实现对象交互过程。
ConcreteMediator* m=new ConcreteMediator();
ConcreteColleageA* c1=new ConcreteColleageA(m);
ConcreteColleageB* c2=new ConcreteColleageB(m);
m->Init(c1,c2); //获取两者实例
c1->Action();
c2->Action();
9.迭代器模式（Iterator）：解决遍历问题
保存在_objs[]数组的对象对外提供GetItem()接口供调用。
Aggregate* ag=new ConcreteAggregate();
Iterator* it=new ConcreteIterator(ag);
for (;!(it->IsDone());it->Next())
{
cout<<it->CurrentItem()<<endl;
}
10.解释器模式（Interpreter）：（未觉得有什么重要用处）
Info为附加信息，AbstractExpressionA和AbstractExpressionB为两种表达式的解
释方式
Info* c=new Context();
AbstractExpression* te=new AbstractExpressionA("hello");
AbstractExpression* nte=new AbstractExpressionB(te,2);
nte->Interpret(*c);
11.责任链模式（chain of responsibility）：将处理请求对象练成一个链，请求在链上传
递，直到被处理
ConcreteHandleA对象当请求HandleRequest到来时，先通过Getsuccessor（）查看
自己有没有后继，如果有则交给后继处理ConcreteHandleB，没有则自己处理。
Handle* h1=new ConcreteHandleA();
Handle* h2=new ConcreteHandleB();
h1->SetSuccessor(h2);
h1->HandleRequest();
面向对象设计原则：优先使用对象组合，少用继承
继承：易于修改、扩展复用，但父类改变则子类必须改变（白盒复用）
组合：组合对象和被组合对象之间依赖小，隐藏被组合对象内部细节（黑盒复用）
