C++ 设计模式

一、简介

实现低耦合度、（高）可复用的面向对象的设计模式。

对象：1.封装代码和数据；2.一系列可以使用公共接口；3.某种拥有责任的抽象

二、设计原则

1、依赖倒置原则（DIP）（隔离高层模块与实现细节）

（1）高层模块（稳定）不应该依赖底层模块（变化），二者都依赖与抽象（稳定）

（2）抽象（稳定）不应该依赖与实现细节（变化），实现细节应该依赖与抽象（稳定）

2、开放封闭原则（OCP）

（1）对扩展开放，对更改封闭

（2）类模块应该是可以扩展的，但是不可以修改

3、单一职责原则（SRP）

（1）一个类应该仅有一个引起他变化的原因

（2）变化的方向隐含着类的责任

4、Liskov替换原则（LSP）

（1）子类必须能够替换它的基类（IS-A）

（2）继承表达类抽象

5、接口隔离原则（ISP）

（1）不应该强迫客户程序依赖它们不用的方法

（2）接口应该小而完备

6、优先对象组合，而不是类继承

（1）类继承通常为“白箱复用”，对象组合通常为“黑箱复用”

（2）集成在某种程度上破坏了封装性，子类父类耦合度高

（3）对象组合只要求被组合的对象具有良好的定义的接口，耦合度低

7、封装变化点

（1）使用封装来创建对象直接的分界层

8、针对接口编程，而不是针对实现编程

（1）不将变量类型声明为某个特定的具体类，而是声明为某个接口

（2）客户程序无需获知对象的具体类型，只需要知道对象所具有的接口

（3）减少系统中各部分的依赖关系，从而实现“高内聚，低耦合”的类型设计方案

三、重构关键技法

        静态->动态

        早绑定->晚绑定

        继承->组合

        编译时依赖->运行时依赖

        紧耦合->松耦合

四、模式

1、组件协作模式：晚绑定

（1）Template Method（模板方法）

       使用原因：

                1.使用同一套框架实现不同的功能

                2.在已经实现的框架中，添加一些新功能

        原理：父类给出的逻辑骨架调用由子类实现的动态方法（虚函数），实现稳定方法（父类）具有变化功能。

//模板类（抽象类）
class AbstractClass
{
    public：
    ~AbstractClass();
    
    void Run()
    {
      step1();
      step2();
      step3();  
    }

    void step1()
    {  ...  }
    void step3()
    {  ...  }
    virtual void step2();
}

//多态实现
class ConcreteClass: public AbstractClass
{
    public:
    void step2()
    {    ...    }
}

//调用应用
class UseClass
{
    public:
    UseClass(AbstractClass* abstractClass)
    {
        m_obj = abstractClass;
    }
    ~UseClass()
    {
        delete m_obj;
    }

    void DoSomeThing()
    {
        ...
        m_obj->Run();
        ...
    }
    private:
    AbstractClass *m_obj;
}

（2）Strategy（策略模式）

        使用原因：依赖的单一算法，多种算法之间可相互替代

        原理：父类给出的接口由子类实现的动态方法（虚函数），实现稳定方法（父类）具有变化功能。

//模板类（抽象类）
class AbstractClass
{
    public：
    ~AbstractClass();
    
    virtual void work();
}

//多态实现1
class ConcreteClass1: public AbstractClass
{
    public:
    void work()
    {    ...    }
}
//多态实现2
class ConcreteClass2: public AbstractClass
{
    public:
    void work()
    {    ...    }
}

//调用应用
class UseClass
{
    public:
    UseClass(AbstractClass* abstractClass)
    {
        m_obj = abstractClass;
    }
    ~UseClass()
    {
        delete m_obj;
    }

    void DoSomeThing()
    {
        ...
        m_obj->work();
        ...
    }
    private:
    AbstractClass *m_obj;
}

UseClass use1(new ConcreteClass1());
UseClass use2(new ConcreteClass2());

（3）Observer/Event（观察者模式）

        使用原因：一对多的依赖，当发生变化时，依赖的它的对象都接受通知

class ObServer
{
   virtual void Update(int count)=0;
}

class MyObServer: public ObServer
{
    public:
    virtual void Update(int count)
    {
        //DoSomeThing
    }
}

//调用应用
class UseClass
{
    public:
    void AddObServer(ObServer* observer)
    {
        m_observer.push_back(observer);
    }
    void DelObServer(ObServer* observer)
    {
        m_observer.erease(observer);
    }
    void UndateObServer(int count)
    {
        vector<ObServer*>::iterator iter;
        while(m_observer.end() != iter)
        {
            iter->Update(int count);
        }
    }
    
    Run()
    {
        ...
        UndateObServer();
        ...
    }
    
    private:
    vector<ObServer*>m_observer;
}