[Boolan] C++第十一周 C++设计模式（一 ）

一. 面向对象设计原则

1. 依赖倒置原则 ( DIP )

- 高层模块 (稳定) 不应该依赖于底层模块 (变化) , 二者都应该依赖于抽象
- 抽象 (稳定) 不应该依赖于实现细节 (变化)，实现细节都应该依赖于抽象

2. 开放封闭原则 ( OCP )

- 对扩展开放，对更改封闭
- 类模块应该是可扩展的，但是不可修改

3. 单一职责原则 (SRP)

- 一个类应该仅有一个引起它变化的原因
- 变化的方向隐含着类的责任

4. Liskov替换原则 (LSP)

- 子类必须能够替换他们的基类 (IS-A)
- 继承表达类型抽象

5. 接口隔离原则 (ISP)

- 不应该强迫客户程序依赖他们不用的方法
- 接口应该小而完备

6. 优先使用对象组合，而不是类继承

- 类继承通常为 "白箱复用" ，对象组合通常为 "黑箱复用"
- 继承在某种程度上破坏了封装性， 子类父类耦合度高。
- 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低

7. 封装变化点

- 使用封装来创建对象之间的分界层，让设计者可以在分界点一侧进行修改，而不会对另一侧产生不良的影响，
  从而实现层次间耦合

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

- 不将变量类型声明而某个特定的具体类，而是声明为某个接口
- 客户程序无需获知对象的具体类型，只需知道对象所具有的接口
- 减少系统中各部分的依赖关系， 从而实现“高内聚，松耦合” 的类型设计方案

标准

二. 设计模式

组件协作

1. Template Method - 模版方法

Template 模式是采用继承的方式实现这一点:将逻辑(算法)框架放在抽象基类中，并 定义好细节的接口，子类中实现细节。

类图

Template 模式获得一种反向控制结构效果，这也是面向对象系统的分析和设计中一个原
则 DIP(依赖倒置:Dependency Inversion Principles)。其含义就是父类调用子类的操作(高 层模块调用低层模块的操作)，
低层模块实现高层模块声明的接口。这样控制权在父类(高 层模块)，低层模块反而要依赖高层模块。

简略代码实现

#include <stdio.h>
#include <iostream>

using namespace std;

class AbstractClass {
public:
    void TemplateMethod() {
        primitiveOperation1();
        primitiveOperation4();
        primitiveOperation2();
        primitiveOperation3();
    }

    void primitiveOperation1() {    }
    void primitiveOperation4() {    }
protected:
    void primitiveOperation2() {    }
    void primitiveOperation3() {    }
};

class ConcreteClass : public AbstractClass {
protected:
    void primitiveOperation2() {    }
    void primitiveOperation3() {    }
};
int main(int argc, char *argv[])
{
    ConcreteClass c;
    c.TemplateMethod();

    return 0;
}

2. Stragety - 策略模式

Strategy 模式将逻辑(算法)封装到一个类(Context) 里面，通过组合的方式将具体算法的实现在组合对象中实现，

再通过委托的方式将抽象接口 的实现委托给组合对象实现

#include <stdio.h>
#include <iostream>

using namespace std;

class Stragegy{
public:
    virtual void AlgrithmInterface() = 0;
    virtual ~Stragegy(){};
};

class ConcreteStrategyA : public Stragegy
{
public:
    void AlgrithmInterface() {
        printf("algorithm 1");
    }
};

class ConcreteStrategyB : public Stragegy
{
public:
    void AlgrithmInterface() {
        printf("algorithm 2");
    }
};

class Context {
public:
    void DoAction() {
        m_s->AlgrithmInterface();
    }
    Context(Stragegy *s)
    :m_s(s) {}
    ~Context() {
        if(m_s) delete m_s;
    }
private:
    Stragegy *m_s;
};

int main(int argc, char *argv[])
{
    Stragegy *s = new ConcreteStrategyA();
    Context c(s);
    c.DoAction();

    return 0;
}

3. Observer - 观察者模式

目标对象的状态发生改变，所有的观察者对象都将得到通知
定义对象间的一种一对多(变化)的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象得到通知并自动更新

#include <list>
#include <string>
#include <iostream>

using namespace std;

//观察者的基类
class Subject;
class Observer {
public:
    virtual ~Observer(){     }
    virtual void Update(Subject* sub) = 0;
    virtual void PrintInfo() = 0;
protected:
    Observer(){
        _st = "";
    }

    string _st;
};

^^^^^^^^^^^^^^^^^^^^观察的对象
class Subject {
public:
    virtual ~Subject(){
        if(_obvs) { delete _obvs;}
    }
    virtual void Attach(Observer* obv){
        _obvs->push_back(obv);
    }
    virtual void Detach(Observer* obv){
        if(obv != NULL) {
            _obvs->remove(obv);
        }
    }
    virtual void Notify() {
        list<Observer*>::iterator it = _obvs->begin();
        for(; it != _obvs->end(); it++) {
            (*it)->Update(this);
        }
    }

    virtual void SetState(const string &st) = 0;
    virtual string GetStatus() = 0;
protected:
    Subject() { _obvs = new list<Observer*>;}
private:
    list<Observer*> * _obvs;
};


class ConcreteSubject : public Subject
{
public:
    ConcreteSubject() {_st= "";}
    ~ConcreteSubject(){}

    string GetStatus(){ return _st;}
    void SetState(const string &st) { _st = st;}
private:
    string _st;
};

///^^^^^^^^^^^^^^^^^^^^^^^^^^^观察者

class ConcreteObserverA : public Observer 
{
public:
    ConcreteObserverA(Subject* sub) {
        _sub = sub;
        _sub->Attach(this);
    }

    virtual ~ConcreteObserverA(){
        if(_sub) {
            _sub->Detach(this);
        }
    }

    Subject* GetSubject() {
        return _sub;
    }

    void Update(Subject* sub){
        _st = sub->GetStatus();
        PrintInfo();
    }
    void PrintInfo(){
        cout << "ConcreteObserverA get notify." <<endl;
    }
private:
    Subject *_sub;
};

class ConcreteObserverB : public Observer 
{
public:
    ConcreteObserverB(Subject* sub) {
        _sub = sub;
        _sub->Attach(this);
    }

    virtual ~ConcreteObserverB(){
        if(_sub) {
            _sub->Detach(this);
        }
    }

    Subject* GetSubject() {
        return _sub;
    }

    void Update(Subject* sub){
        _st = sub->GetStatus();
        PrintInfo();
    }

    void PrintInfo(){
        cout << "ConcreteObserverB get notify." <<endl;
    }
private:
    Subject *_sub;
};

int main(int argc, char *argv[])
{
    ConcreteSubject * sub = new ConcreteSubject();

    Observer* o1 = new ConcreteObserverA(sub);
    Observer* o2 = new ConcreteObserverB(sub);

    sub->SetState("old");
    sub->Notify();
    sub->SetState("new");

    sub->Notify();

    delete o2;
    delete o1;
    delete sub;


    return 0;
}

单一职责模式

4. Decorator - 装饰器模式

通过组合的方式，给已经定义好的类增加新的职责／操作，比生成子类更为灵活

//
//  week11_Decorator.cpp
//  Boolan
//
//  Created by 张峰 on 29/03/2017.
//  Copyright © 2017 张峰. All rights reserved.
//

//
//  week11_Decorator.cpp
//  Boolan
//
//  Created by 张峰 on 29/03/2017.
//  Copyright © 2017 张峰. All rights reserved.
//

#include <stdio.h>
#include <iostream>

using namespace std;

class Component {
public:
    virtual ~Component() {}
    virtual void Operation() {  }
protected:
    Component(){}
};

class ConcreteComponent:public Component {
public:
    ConcreteComponent(){}
    ~ConcreteComponent(){}

    virtual void Operation(){
        std::cout<< "ConcreteComponent Operation" << std::endl;
    }
};

class Decorator : public Component {
public:
    Decorator(Component* com)
    :_com(com){}
    virtual ~Decorator() {
        if(_com) delete _com;
    }
    virtual void Operation(){}
protected:
    Component* _com;
};

class ConcreteDecorator : public Decorator {
public:
    ConcreteDecorator(Component* com)
    :Decorator(com)
    {}
    ~ConcreteDecorator(){}

    virtual void Operation(){
        _com->Operation();
        this->AddedBehavior();
    }
    void AddedBehavior(){
        std::cout << "ConcreteDecorator AddedBehavior"<< std::endl;
    }
};


int main(int argc, char * argv[])
{
    Component *p = new ConcreteComponent();

    Decorator *dc = new ConcreteDecorator(p);

    dc->Operation();
    delete dc;

    return 0;
}

5. Bridge - 桥模式

将抽象部分与它的实现部分分离，使得它们可以独立地变化

//
//  week11_Bridge.cpp
//  Boolan
//
//  Created by 张峰 on 02/04/2017.
//  Copyright © 2017 张峰. All rights reserved.
//

#include <iostream>

using namespace std;

//动作接口的基类
class AbstractionImp
{
public:
    virtual ~AbstractionImp(){}
    virtual void Operation() = 0;
protected:
    AbstractionImp(){}
};

class Abstraction{
public:
    virtual ~Abstraction(){ 
    }

    virtual void Operation() = 0;

protected:
    Abstraction(){}
};

class RefinedAbstraction : public Abstraction
{
public:
    RefinedAbstraction(AbstractionImp* imp)
    :_imp(imp){

    }
    ~RefinedAbstraction(){}
    void Operation(){
        _imp->Operation();
    }
private:
    AbstractionImp* _imp;
};

class ConcreteAbstractionImpA : public AbstractionImp
{
public:
    ConcreteAbstractionImpA(){}
    ~ConcreteAbstractionImpA(){}
    virtual void Operation(){
        std::cout << "ConcreteAbstractionImpA" << std::endl;
    }
};


class ConcreteAbstractionImpB : public AbstractionImp
{
public:
    ConcreteAbstractionImpB(){
        std::cout << "ConcreteAbstractionImpB" << std::endl;
    }
    ~ConcreteAbstractionImpB(){}
    virtual void Operation(){}
};



int main(int argc, char *argv[])
{
    AbstractionImp* imp = new ConcreteAbstractionImpA(); 
    Abstraction* abs = new RefinedAbstraction(imp); 
    abs->Operation();

    return 0;
}