设计模式之策略模式

1. #include <iostream>
3. using namespace std;
5. // 飞行行为接口类
6. class FlyStrategy
7. {
8. public:
10.     virtual void Fly() = 0;
12. protected:
14.     FlyStrategy(){}
15. };
17. // 高空飞行行为具现类
18. class HeightFly:public FlyStrategy
19. {
20. public:
22.     static HeightFly &GetSingleton()
23.     {
24.         static HeightFly s_HeightFly;
25.         return s_HeightFly;
26.     }
28.     virtual void Fly()
29.     {
30.         cout << "It is a heightfly behavior." << endl;
31.     }
33. private:
35.     HeightFly(){}
36. };
38. // 低空飞行行为具现类
39. class LowFly:public FlyStrategy
40. {
41. public:
43.     static LowFly &GetSingleton()
44.     {
45.         static LowFly s_LowFly;
46.         return s_LowFly;
47.     }
49.     virtual void Fly()
50.     {
51.         cout << "It is a lowfly behavior." << endl;
52.     }
54. private:
56.     LowFly(){}
57. };
59. // 叫声行为接口类
60. class SoundStrategy
61. {
62. public:
64.     virtual void MakeSound() = 0;
66. protected:
68.     SoundStrategy(){}
69. };
71. // 大声叫行为具现类
72. class LoudlySound:public SoundStrategy
73. {
74. public:
76.     static LoudlySound &GetSingleton()
77.     {
78.         static LoudlySound s_LoudlySound;
79.         return s_LoudlySound;
80.     }
82.     virtual void MakeSound()
83.     {
84.         cout << "It is a loudlysound behavior." << endl;
85.     }
87. private:
89.     LoudlySound(){}
90. };
92. // 小声叫行为具现类
93. class SmallSound:public SoundStrategy
94. {
95. public:
97.     static SmallSound &GetSingleton()
98.     {
99.         static SmallSound s_SmallSound;
100.         return s_SmallSound;
101.     }
103.     virtual void MakeSound()
104.     {
105.         cout << "It is a smallsound behavior." << endl;
106.     }
108. private:
110.     SmallSound(){}
111. };
113. // 鸭子具现类
114. class Duck
115. {
116. private:
118.     // 行为接口
119.     FlyStrategy *m_pFlyStrategy;
120.     SoundStrategy *m_pSoundStrategy;
122. public:
124.     // 带参数构造函数
125.     Duck(FlyStrategy *p_pFlyStrategy, SoundStrategy *p_pSoundStrategy):
126.       m_pFlyStrategy(p_pFlyStrategy),m_pSoundStrategy(p_pSoundStrategy){}
128.     // 飞行
129.     void Fly()
130.     {
131.         m_pFlyStrategy->Fly();
132.     }
134.     // 发出叫声
135.     void Sound()
136.     {
137.         m_pSoundStrategy->MakeSound();
138.     }
140.     // 动态设置行为接口
141.     void SetFlyStrategy(FlyStrategy *p_pFlyStrategy)
142.     {
143.         m_pFlyStrategy = p_pFlyStrategy;
144.     }
146.     void SetSoundStrategy(SoundStrategy *p_pSoundStrategy)
147.     {
148.         m_pSoundStrategy = p_pSoundStrategy;
149.     }
151.     // 显示虚函数
152.     virtual void Display() const
153.     {
154.         cout << "This is a ordinary duck." << endl;
155.     }
156. };
158. int main()
159. {
160.     // 创建鸭子对象
161.     Duck duck(&HeightFly::GetSingleton(), &LoudlySound::GetSingleton());
163.     // 作出行为
164.     duck.Fly();
165.     duck.Sound();
167.     // 动态切换鸭子行为
168.     duck.SetFlyStrategy(&LowFly::GetSingleton());
169.     duck.SetSoundStrategy(&SmallSound::GetSingleton());
171.     // 作出新一轮的行为
172.     duck.Fly();
173.     duck.Sound();
175.     system("pause");
176.     return 0;
177. }
179. 策略模式理解:策略模式的核心理念是将类型中变换的部分(行为接口)分离到外部,并以特定的一组类对其进行实现,
180.            而在原类型内部只保留各行为抽象基类接口的指针,通过委托的方式实现用户的请求并提供Setter函数方
181.            便用户动态地改变行为的类型.
183. 继承的缺点:白箱复用的特性导致子类默认继承一份缺省实现,将易变化的实现代码整合进类型定义将导致日后增加新
184.       的实现或进行实现的修改尤为困难.每次当需要新的需求时都需要覆盖以前的实现,容易导致类泛滥,不能达到完
185.       全的代码复用.
187. 组合的优点:黑箱复用的方式不会暴露实现的细节,分离封装变化的部分增加可维护性和易扩展性,并带来完全的代码复用.
188.       基于接口的编程使得可以动态的改变行为类型.