设 计 模 式

设计模式

1. 单一职责原则（Single-Responsibility-Principle）
    该原则是针对类来说的，即一个类应该只负责一项职责。如类T负责两个不同职责：职责P1，职责P2。当职责P1需求变更而改变T时，可能造成职责P2发生故障，所以需要将类T的粒度分解为T1，T2。

2. 开闭原则（Open Close Principle）
    对扩展开放，对修改关闭

3. 里氏代换原则（Liskov Substitution Principle）
    该原则是在1988年，由麻省理工学院的一位姓里的女士提出的。 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。 

    换句话说，所有引用基类的地方必须能透明地使用其子类的对象。 
由定义可知，在使用继承时，遵循里氏替换原则，在子类中尽量不要重写和重载父类的方法。
    继承作为面向对象三大特性之一，在给程序设计带来巨大便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障。

4. 依赖倒转原则（Dependence Inversion Principle）
    高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。依赖倒置原则基于这样一个事实：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。

5. 接口隔离原则（Interface Segregation Principle）
    客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。 
类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类C来说不是最小接口，则类B和类D必须去实现他们不需要的方法。如果将臃肿的接口I拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

6. 迪米特法则，又称最少知道原则（Demeter Principle）
    一个对象应该对其他对象保持最少的了解。类与类关系越密切，耦合度越大。迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。

7. 合成复用原则（Composite Reuse Principle）
   合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

#include <iostream>
using namespace std;

class ElaphanToFridge{
public:
    void templateStep(){     方法、办法
        firstStep();
        secondStep();
        thirdStep();
    }
protected:
    virtual void firstStep() = 0;
    virtual void secondStep() {cout << "Second step" << endl;}
    virtual void thirdStep() = 0;
};

class Somth : public ElaphanToFridge{      //事件
    void firstStep(){ cout << "First step" << endl; }
    void thirdStep(){ cout << "Third step" << endl; }
};

int main()
{
    ElaphanToFridge obj;
    obj.templateStep();
    
    return 0;
}

单例模式：构造析构拷贝构造私有，静态函数使用静态私有成员调用分配内存

#include <iostream>
using namespace std;

class Single{
public:
    static Single * createHandler()
    {    
        if(handler == NULL)
        {
            handler = new Single();
        }
        return handler;
    }
    
    void destroyHandler(){
        if(handler != NULL){
            delete handler;
            handler = NULL;
        }
    }

private:
   Single(){}
   Single(const Single& o){}
   ~Single(){}
   static Single *handler;
};

Single *Single::handler = NULL;

int main()
{
    Single *ptr = Single::createHandler();
    Single *str = Single::createHandler();
    return 0;
}

工厂模式

#include <iostream>
using namespace std;
//观察者模式
//工厂模式：简单工厂,工厂方法,抽象工厂

class Product{
    virtual void show() = 0;
};

class ProductA : public Product{
public:
    void show(){ cout << "ProductA" << endl; }
};

class ProductB : public Product{
    void show(){ cout << "ProductB" << endl; }
};

class ProductC : public Product{
    void show(){ cout << "ProductC" << endl;}
};

class Factory{
public:
    Product *getProduct(int type){
        if(type == 1){
            return new ProductA();
        }else if(type ==2){
            return new ProductB();
        }else{
            return new ProductC();
        }
    }
};

int main()
{
    Factory f;
    Product *p = f.getProduct(1);
    p->show();
    return 0;
}

工厂方法：一个工厂对应一个产品

#include <iostream>
using namespace std;
//观察者模式
//工厂模式：简单工厂,工厂方法,抽象工厂

class Product{
    virtual void show() = 0;
};

class ProductA : public Product{
public:
    void show(){ cout << "ProductA" << endl; }
};

class ProductB : public Product{
    void show(){ cout << "ProductB" << endl; }
};

class ProductC : public Product{
    void show(){ cout << "ProductC" << endl;}
};

class Factory{
public:
    virtual Product *getProduct() = 0;
};

class FactoryA : public Factory{
public:
    virtual Product *getProduct() {
        return new ProductA();
    }
};

class FactoryB : public Factory{
    virtual Product *getProduct() {
        return new ProductB();
    }
};

class FactoryC : public Factory{
    virtual Product *getProduct() {
        return new ProductC();
    }
};

int main()
{
    Factory *f = new FactoryA;
    Product *p = f->getProduct();
    p->show();
    return 0;
}

抽象工厂

#include <iostream>
using namespace std;
//观察者模式
//工厂模式：简单工厂,工厂方法,抽象工厂

class Car{
public:
    virtual void show() = 0;
};

class BmwCar : public Car{
public:
    virtual void show() {
        cout << "BmwCar" << endl;
    }    
};

class BydCar : public Car{
public:
    virtual void show() {
        cout << "BydCar" << endl;
    }

class Suv{
public:
    virtual void test() = 0;
};

class BmwSuv : public Suv{
public:
    virtual void test() {
        cout << "BmwSuv" << endl;
    }
};

class BydSuv : public Suv{
public:
    virtual void test() {
        cout << "BydSuv" << endl;
    }
};


class CarFactory{
public:
    virtual Car *createCar() = 0;
    virtual Suv *createSuv() = 0;
};

class BmwCarFactory : public CarFactory{
public:
    virtual Car *createCar() {
        return new BmwCar();
    }
    virtual Suv *createSuv() {
        return new BmwSuv();
    }
};

class BydCarFactory : public CarFactory{
public:
    virtual Car *createCar() {
        return new BydCar();
    }
    virtual Suv *createSuv() {
        return new BydSuv();
    }
};

int main()
{
    CarFactory *f = new BmwCarFactory;
    Car *c = f->createCar();
    p->show();

    Suv *s = f->createSuv();
    p->show();

    return 0;
}

观察者模式

#include <iostream>
#include <list>
using namespace std;
//观察者模式
//工厂模式：简单工厂,工厂方法,抽象工厂

class Subject {
public:
    virtual void update() = 0;
};

class GameSubject : public Subject{
public:
    virtual void update() { cout << "GameSubject" << endl; }
};

class StorySubject : public Subject{
public:
    virtual void update() { cout << "StorySubject" << endl; }
};

class Observer{
public:
    void detach(Subject *sub) {
        m_sub.remove(sub);
    }
    void attach(Subject *sub) {
        m_sub.push_back(sub);
    }
    void notify(Subject *sub) {
        list<Subject *>::iterator it;
        for(it = sub.begin(); it != sub.end(); ++it){
            (*it)->update();
        }
    }
private:
    list<Subject *> m_sub;
};

int main()
{
    GameSubject sub1;
    StorySubject sub2;

    Observer obj;
    obj.attach(&sub1);
    obj.attach(&sub2);
    obj.notify();
    return 0;
}