C++ ：设计模式实现

原则

单一职责原则

定义：
即一个类只负责一项职责

问题：
类 T 负责两个不同的职责：职责 P1，职责 P2。当由于职责 P1 需求发生改变而需
要修改类 T 时，有可能会导致原本运行正常
的职责 P2 功能发生故

解决：
将类 T 分成两个不同的类来实现。

开闭原则

定义：
如类、模块和函数应该对扩展开放，对修改关闭

问题：
在软件的生命周期内，因为变化、升级和维护等原因需要对软件原有代码进行修改
时，可能会给旧代码中引入错误，也可能会使我们不得不对整个功能进行重构，并且需
要原有代码经过重新测试

解决：
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化

依赖倒置原则

定义：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象

问题：
类 A 直接依赖类 B，假如要将类 A 改为依赖类 C，则必须通过修改类 A 的代码来达成。这种场景下，类 A 一般是高层模块，负责复杂的业务逻辑；类 B 和类 C 是低层模
块，负责基本的原子操作；假如修改类 A，会给程序带来不必要的风

解决：
将类 A 修改为依赖接口 I，类 B 和类 C 各自实现接口 I，类 A 通过接口 I 间接与类 B或者类 C 发生联系，则会大大降低修改类 A 的几率

接口隔离原则

定义：
客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上

问题：
类 A 通过接口 I 依赖类 B，类 C 通过接口 I 依赖类 D，如果接口 I 对于类 A 和类 B来说不是最小接口，则类 B 和类 D 必须去实现他们不需要的方法

解决：
将臃肿的接口 I 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依
赖关系。也就是采用接口隔离原则

里氏替换原则

定义：
所有引用基类的地方必须能透明地使用其子类的对象，子类可以扩展父类的功能，但不能改变父类原有的功能。

问题：
当使用继承时，遵循里氏替换原则。类 B 继承类 A 时，除添加新的方法完成新增
功能 P2 外，尽量不要 shadow(遮盖)父类 A 的方法。

解决：
子类中可以增加自己特有的方法；
子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法（多态实现）

设计模式

单例模式

定义：
确保某一个类只有一个实例， 而且自行实例化并向整个系统提供这个实例
问题：
几个不同的客户对象需要引用同样的对象，你希望确保自己拥有的这种对象不超过一个
解决：

1. 在 Singleton 中添加静态成员，初始化为NULL
2. 添加静态成员方法，若静态成员变量为 NULL,则实始化并返回
3. 将构造成员，设为 private 或是 protected，这样只能通过静态方法实例化

类关系图：

实现：

#include 
using namespace std;
class Singleton
{
public:
    static Singleton* getInstance()
    {
        if(_ins == NULL)
            _ins = new Singleton;
        return _ins;
    }
    static void releaseInstance()
    {
        if(_ins != NULL)
        {
            delete _ins;
            _ins = NULL;
        }
    }
    void run()
    {
        cout<<"test singleton"<<endl;
    }
private:
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton &){}
    Singleton & operator=(const Singleton&){}
    static Singleton * _ins;
};
Singleton * Singleton::_ins = NULL;
int main()
{
    Singleton * ps = Singleton::getInstance();
    ps->run();
    Singleton::releaseInstance();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

观察者模式

定义：
定义对象间一种一对多的依赖关系， 使得每当一个对象改变状态， 则所有依赖于它的对象都会得到通知并被自动更新，也成为发布-订阅模式
问题：
当某个事件发生变化时，你需要向一系列对象发出通知，而这个对象的列表也是不断变化的。
解决：
Observer 将监视某个事件上的责任委托给一个中心对象：Subject ，当事件发生时，Subject 告诉 Observer“你关心的事件发生了”

类关系图：

实现：

// 观察者模式实现 时间更新

#include 
#include 
#include 
using namespace std;

// 观察者模式，又称为订阅模式 ，比如关注的公众号更新会自动发送到手机上

class Observer
{
public:
    virtual void update(int hour, int min ,int sec) = 0;
};

class Subject
{
public:
    virtual void registerObserver(Observer * ob) = 0;
    virtual void removeObserver(Observer *ob) = 0;
    virtual void notify() = 0;
protected:
    list<Observer*> observerList;
};

class PekingTimeSubject:public Subject
{
public:
    void setTimer(int hour, int min, int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        notify();
    }
    void registerObserver(Observer * ob)
    {
        observerList.push_back(ob);
    }
    void removeObserver(Observer *ob)
    {
        //observerList.erase(find(observerList.begin(),observerList.end(),ob));
        observerList.remove(ob);
    }
    void notify() // 此函数必须在子类中实现，因为，要接触数据。
    {
        list<Observer*>::iterator itr = observerList.begin();
        for(; itr != observerList.end(); itr++)
        {
            (*itr)->update(_hour,_min,_sec);
        }
    }
private:
    int _hour;
    int _min;
    int _sec;
};
class AmericaTimerObserver:public Observer
{
public:
    void update(int hour, int min ,int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        dis();
    }
    void dis()
    {
        cout<<"America Time is update"<<endl;
        cout<<"H:"<<_hour<<" M:"<<_min<<" S:"<<_sec<<endl;
    }
private:
    int _hour;
    int _min;
    int _sec;
};
class JapanTimerObserver:public Observer
{
public:
    void update(int hour, int min ,int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        dis();
    }
    void dis()
    {
        cout<<"Japan Time is update"<<endl;
        cout<<"H:"<<_hour<<" M:"<<_min<<" S:"<<_sec<<endl;
    }
private:
    int _hour;
    int _min;
    int _sec;
};
int main()
{
    PekingTimeSubject *bj = new PekingTimeSubject;
    JapanTimerObserver *jp = new JapanTimerObserver;
    AmericaTimerObserver *am = new AmericaTimerObserver;
    bj->registerObserver(jp);
    bj->registerObserver(am);
    bj->setTimer(10,20,30);
    bj->removeObserver(jp);
    bj->setTimer(1,2,3);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

策略模式

定义：
提供便利的的功能/算法切换

问题：
将变动的策略写死在，固定的代码中。不利于更改和维护

解决：
将策略抽象出来，进行封装
Strategy(策略）： 所有支持的算法的公共接口
Context(上下文)

类关系图：

实现：
// 实现游戏人物通过相同按键切换武器

#include 

using namespace std;

// 定义了一组算法，进行封装

class Weapon
{
public:
    virtual void use() = 0;
};

class Knife :public Weapon
{
public:
    void use()
    {
        cout<<" dao ni "<<endl;
    }
};
class Gun :public Weapon
{
public:
    void use()
    {
        cout<<" tutu ni "<<endl;
    }
};

class CCsprite
{
public:
    CCsprite(Weapon *k)
    {
        _w = k;
    }
    void changWeapon(Weapon *w)
    {
        _w = w;
    }
    void faighting()
    {
        _w->use();
    }
protected:
    Weapon *_w;
};
int main()
{
    Knife k;
    CCsprite character(&k);
    character.faighting();
    Gun g;
    character.changWeapon(&g);
    character.faighting();
    character.changWeapon(&k);
    character.faighting();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

代理模式

定义：
（为其他对象
提供一种代理以控制对这个对象的访问
问题：
对一个对象进行访问控制的一个原因是为了只有在我们确实需要这个对象时才对它进行创建和初始化
解决：
对被访问的提供一个壳
Subject 抽象主题角色
ConcreteSubject 具体主题角色也叫做被委托角色、 被代理角色，是业务逻辑的具体执行者
ProxySubject 代理主题角色，负责对真实角色的应用

类关系图：

实现：
//模拟加载页面中先显示文字，后显示图片的过程

#include 
#include 
using namespace std;

// LargeImage 为自己，显示图片，需要先构造6s
// ProxyLargeImage 为它的代理，他们都继承虚基类ImageSubject，代理LargeImage调用图像
class Text
{
public:
    void showText()
    {
        cout<<"wed text is show "<<endl;
    }
};
class ImageSubject
{
public:
    virtual void showPicture() = 0;
};

class LargeImage:public ImageSubject
{
public:
    LargeImage()
    {
        sleep(6);
    }
    virtual void showPicture()
    {
        cout<<"xiang ri kui \n"<<endl;
    }
};

class ProxyLargeImage:public ImageSubject
{
public:
    ProxyLargeImage():li(NULL){}
    void showPicture()
    {
        if(li == NULL)
            li = new LargeImage;
        li->showPicture();
    }
protected:
    LargeImage *li;
};
class Document
{
public:
    Document()
    {
        _t = new Text; //1
        _i = new ProxyLargeImage; //1000
    }
    void print()
    {
        _t->showText();
        _i->showPicture();
    }
    Text *_t;
    ProxyLargeImage *_i;
};
int main(int argc, char *argv[])
{
    Document doc;
    doc.print(); // 一分部加载文件字，一部分加载图片
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69