[读书笔记]大话设计模式(程杰)
https://github.com/iyjhabc/Design-Pattern
第一章：简单工厂模式
使用一个工厂类来根据参数调用不同的函数。因此增加功能时只需改变工厂类以及新增函数即可。
class oper { protected://使用保护成员，子类可以访问。子类不能访问私有成员 double lhs; double rhs; public: double virtual getResult()=0;//纯虚函数 void set_lhs(double lhs){this->lhs=lhs;} void set_rhs(double rhs){this->rhs=rhs;} }; class oper_add:public oper { public: double getResult(){ return lhs+rhs; } }; class oper_minus:public oper { public: double getResult(){ return lhs-rhs; } }; class factory { oper *op; public: factory(){op=NULL;} ~factory(){if(op)delete op;} oper* createOperator(char oper_char){ switch(oper_char){ case '+':op=new oper_add;break; case '-':op=new oper_minus;break; default:cout<<"operator error"<<endl; } return op; } }; //用户代码，计算器 double clientCounter(double lhs,double rhs,char oper_char){ factory fac; oper *op=fac.createOperator(oper_char); if(op==NULL)return 0; op->set_lhs(lhs); op->set_rhs(rhs); return op->getResult();//使用父类指针调用纯虚函数实现多态 }
第二章：策略模式
使用于对同一对象使用多种算法。而且算法经常需要修改或者替换。策略模式能使用户代码与算法隔离，修改算法代码不需要修改用户代码。
class Strategy { public: virtual double algorithm(double cash){//虚函数，用户实现多态 return cash; } }; class StrategyA:public Strategy { public: double algorithm(double cash){ return 0.8*cash;//八折 } }; class StrategyB:public Strategy { public: double algorithm(double cash){ return cash>=100?cash-30:cash;//满100减30 } }; class Context { Strategy *stra; public: void loadStrategy(Strategy *s){//加载算法 stra=s; } double getResult(double cash,int mode){ switch(mode){ case 0: this->loadStrategy(new StrategyA);break; case 1: this->loadStrategy(new StrategyB);break; default: this->loadStrategy(new Strategy); } return stra->algorithm(cash); } Context(){stra=NULL;} ~Context(){if(stra)delete stra;} }; //用户只需维护context类。如要增加算法，只需修改context类并给出新的算法类即可。 //用户接触不到算法，实现了算法与用户的隔离。修改算法的时候也无需修改用户代码 double clientFunction(double cash,int mode){ Context context; return context.getResult(cash,mode); }
第三章：单一职责原则
一个类只负责一个单一的职责，只能因为特定一种业务需该改变时才需要修改类。单一职责原则使代码耦合度降低，便于维护和复用。
第四章：开放-封闭原则
对扩展开放，对修改封闭。新增功能时，应该以添加新的类来实现，而不是修改原有代码。
第五章：依赖倒转原则(里氏代换原则)
抽象不应该依赖于细节，细节依赖于抽象。针对接口与抽象类编程，而不是针对实现编程。
依赖翻转原则实现的基础：里氏代换原则-如果父类都替换成它的子类，软件不会有任何问题。例如猫狗养猪都抽象于动物类，当我们的对象从猫换成狗时，由于他们符合里氏代换原则，其他代码不必修改。
第六章：装饰模式
装饰模式能够为对象动态地、有序地新增一些功能。用户代码可以自主地新增功能(用户关心的是以什么顺序增添什么新功能，并不是功能的具体实现)，新增功能时只需添加新的装饰实体类即可，分离了用户的核心功能与个别的装饰功能，而且每种装饰也容易复用。
class Component { public: virtual void operation()=0; }; //具体的对象 class ConcreteComponent:public Component { public: void operation(){cout<<"I am a man"<<endl;} }; //装饰类 class Decorator:public Component { protected: Component *comp; public: Decorator(){comp=NULL;} ~Decorator(){if(comp)delete comp;} void set_component(Component *comp){ this->comp=comp; } void operation(){ if(comp)comp->operation();//关键，运行set_component所设置的行为 } }; //具体装饰类A，穿衣服 class ConcreteDecoratorA:public Decorator { public: void operation(){ Decorator::operation();//执行之前的装饰 cout<<"dress clothes"<<endl;//本装饰类自有的行动 } }; //具体装饰类B，穿裤子 class ConcreteDecoratorB:public Decorator { public: void operation(){ Decorator::operation();//执行之前的装饰 cout<<"dress trousers"<<endl;//本装饰类自有的行动 } }; //客户端代码,穿着函数 void clientDress(){ ConcreteComponent man; ConcreteDecoratorA *decA=new ConcreteDecoratorA; ConcreteDecoratorB *decB=new ConcreteDecoratorB; decA->set_component(&man);//decA父类的comp设置成了man，operation为man的行为 decB->set_component(decA);//decB父类的conp设置成了decA，operation为decA的行为 decB->operation();//先运行祖先decA的operation，而A的operation则先要运行祖先man的。 delete decA;//因此先man->opertion，再A->opertion，再B->opertion delete decB;//其实就是通过set_component每层改变comp为不同的实体装饰 }
第七章：代理模式
设计模式中定义: 为其他对象提供一种代理以控制对这个对象的访问(提供一个壳)。
1) 远程代理（Remote Proxy）为一个位于不同的地址空间的对象提供一个本地的代理对象。例如网站加载大图片时可先加载包含图片位置与尺寸的代理，网站顺利显示后再下载大图片，增加网站响应速度。
2) 虚拟代理（Virtual Proxy）根据需要创建开销很大的对象。如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的代理对象来表示，真实对象只在需要时才会被真正创建。延迟创建真实的消耗大的对象提高系统系敖律。
3) 保护代理（Protection Proxy）控制对原始对象的访问。保护代理用于对象应该有不同的访问权限的时候。
4) 智能指引（Smart Reference）取代了简单的指针，它在访问对象时执行一些附加操作。
代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。
//抽象父类 class Subject { public: void virtual request()=0; }; //真实对象类 class Real_subject:public Subject { public: void request(){ cout<<"my real request"<<endl; } }; //代理类 class Proxy:public Subject { Real_subject *subject; public: void request(){ if(subject==NULL)subject=new Real_subject;//延迟创建Realsubject，用时才创建 cout<<"I am a proxy"<<endl;//通过代理可以添加或屏蔽真实对象的功能 subject->request(); } Proxy(){subject=NULL;} ~Proxy(){if(subject)delete subject;} }; //客户端代码 void dosomething(Subject &subject){ subject.request(); } int main(){ Proxy proxy; dosomething(proxy); return 0; }
第八章：工厂方法模式
与简单工厂模式的区别是，工厂变成一个抽象类，各种功能再独自继承功能工厂类。工厂类不再判断需要返回什么功能类指针，这个判断交给客户代码。如此一来新增功能时，只需增加新的方法子类，新工厂子类以及修改客户代码，不需像简单工厂模式那样修改工厂类的代码，更加符合开放-封闭原则。
代码跟简单工厂差不多：https://github.com/iyjhabc/Design-Pattern/blob/master/factory_mothod_pattern.cpp
第九章：原型模式
原型模式提供了一个浅复制的克隆接口，继承接口的子类可以把原型的当前状态复制到克隆体
优点：1、克隆直接复制内存，不调用构造函数，可以快速克隆初始化开销巨大的对象；2、由于直接复制内存，克隆体跟原型的当前状态完全一致，因此可以动态地根据需要克隆，而不是新建一个初始状态的对象。
注意：克隆提供的是浅复制，就是引用指针这种变量只是把地址直接复制到克隆体，他们指向的对象还是原型所指向的。
//可克隆抽象父类 class Prototype { public: virtual Prototype* clone()=0; static void freeClone(Prototype *pclone){ delete pclone; } }; //实际类，如简历类 class resume:public Prototype { string name; int &age;//引用类型声明时必须初始化，因此必须使用初始化列表 string experience; public: resume(string name,int &age,string experience):name(name),age(age),experience(experience){} void set_age(int new_age){ this->age=new_age; } void display(){ cout<<this->age<<endl<<this->name<<endl<<this->experience<<endl; } Prototype* clone(){//实现深复制的话只能另外new一个resume对象 //因为resume有引用成员变量，引用被初始化以后就不能改变引用目标 resume *presume=(resume*)malloc(sizeof(resume));//直接浅复制，不必调用构造函数 memcpy(presume,this,sizeof(resume));//也无视访问权限 return presume; } }; int main(){ int age=25; resume resumeA("yjh",age,"student"); resumeA.display(); resumeA.display(); resumeA.set_age(26);//动态复制，克隆的结果为最新的值 resume *resumeB=(resume*)resumeA.clone(); resumeB->display(); resumeB->set_age(17);//改变B的age也是也改变了A的 resumeB->display(); resumeA.display();//age=17,浅复制，只复制了地址，克隆体的引用类型还是引用了原型的 Prototype::freeClone(resumeB); return 0; }
第十章：模板模式
声明一个模板抽象类，把固定的操作写入模板函数中。把以后可能改变的部分声明为虚函数，让子类实现，达到代码复用。
//抽象模板类 class Template { public: virtual void altertableOperation1()=0;//模板中的可变操作部分 virtual void altertableOperation2()=0; void fixOperation1(){cout<<"fixOperation1 has done"<<endl;} void fixOperation2(){cout<<"fixOperation2 has done"<<endl;} void templateMethod(){ fixOperation1(); altertableOperation1();//填空，把以后需要改变的地方声明为虚函数 fixOperation2(); altertableOperation2(); } }; //实际应用模板类A class concreteClassA:public Template { public: void altertableOperation1(){ cout<<"classA op1 has done"<<endl; } void altertableOperation2(){ cout<<"classA op2 has done"<<endl; } }; //实际应用模板类B class concreteClassB:public Template { public: void altertableOperation1(){ cout<<"classB op1 has done"<<endl; } void altertableOperation2(){ cout<<"classB op2 has done"<<endl; } }; //用户代码 void client(){ Template *p=new concreteClassA; p->templateMethod(); }
第十二章：外观模式
给同一类子类提供一个简单的、公共的父类，组合子类的方法(如外观接口的methodA是子类1、2、4方法的叠加)，给用户提供接口。用户只需知道外观接口，不必接触里面复杂的细节，使代码便于维护，降低类之间的耦合。
第十三章：建造者模式
用于创建一些复杂的对象，对象内部的建造顺序通常是稳定的，但内部构建通常面临着复杂的变化。因此使用构造者来隔离用户与建造过程，并且使用必须重写的纯虚函数来规定每个产品的生产步骤，而细节必须被重新定制。
class Product { string partA; string partB; public: void set_partA(string partA){ this->partA=partA; } void set_partB(string partB){ this->partB=partB; } void show_product(){ cout<<partA<<" "<<partB<<endl; } }; class Builder { public: virtual void set_partA()=0; virtual void set_partB()=0; virtual Product* get_product()=0; }; class ProductBuilderA:public Builder { Product *product; void set_partA(){//必须重写的纯虚函数 product->set_partA("xx");//私有的，必须利用get_product调用 } void set_partB(){//确保产品必须被定制 product->set_partB("yy"); } public: ProductBuilderA(){ product=new Product; } Product*get_product(){//修改此函数可以改变定制 set_partA();//书中还通过一个director来完成定制，但我感觉集成到这里就可以了 set_partB(); return product; } }; void client(){ Builder *builder=new ProductBuilderA; Product *A=builder->get_product(); A->show_product(); delete builder; delete A; }
第十四章：观察者模式
观察者模式用于一个类与多个类紧密相关，一个类的状态改变了，多个类的状态也要协同改变。使用观察者模式可以把多类之间的关联解耦。使得设计更符合依赖翻转原则，即依赖于抽象。
class Observer { public: virtual void update()=0; }; class Subject//用户可以继承Subject来表达自己的主题 { int state; list<Observer*> observer_list; public: void set_state(int new_state){ this->state=new_state; } int get_state(){ return this->state; } void add_observer(Observer* observer){ observer_list.push_back(observer); } void del_observer(Observer* observer){ observer_list.erase(find(observer_list.begin(),observer_list.end(),observer)); } void notify(){ for(list<Observer*>::iterator it=observer_list.begin();it!=observer_list.end();++it){ (*it)->update();//由subject统一更新observer } } }; class concreteObserverA:public Observer { public: void update(){ cout<<"concreteObserverA is updated"<<endl; } }; class concreteObserverB:public Observer { public: void update(){ cout<<"concreteObserverB is updated"<<endl; } }; void client(){ Observer *observerA=new concreteObserverA; Observer *observerB=new concreteObserverB; Subject *subject=new Subject; subject->add_observer(observerA); subject->add_observer(observerB); subject->set_state(1); if(subject->get_state()){//如果状态改变了，所有的observer需要协同改变 subject->notify(); } delete observerA; delete observerB; delete subject; }
