（四）装饰模式-C++实现

动态地给对象添加一些额外的职责。就功能来说，装饰模式相比派生子类更为灵活。

当需要改进类的某个功能，而不是该类创建的全部对象时，可以使用这种设计模式。

装饰模式中有四种角色;

1、抽象组件：我们需要改进的类的父类，是一个抽象类。定义了一些虚函数。

2、具体组件：也就是它的某些对象可能需要被改进。也叫做被装饰者。

3、装饰：它也是抽象组件的子类，并且还包含一个抽象组件的声明，用来保存被装饰者的引用。它可以是抽象类，也可是是非抽象类。

4、具体装饰：它是装饰的实例。

本例实现的是一个Bird，作为一个抽象组件，即需要被改进的。有三个文件，Bird.h 和Bird.cpp以及测试用的decorator.cpp

实现如下;

1、Bird.h

 1 /*
 2 抽象组件和具体组件的头文件声明
 3 */
 4
 5 #ifndef _BIRD_H_
 6 #define _BIRD_H_
 7
 8 //抽象组件
 9 class Bird{
10 public:
11     virtual int fly() = 0;
12
13 };
14 //具体组件（被装饰者）
15 class Sparrow : public Bird{
16 public:
17     int fly() override; //override代表它是重写的父类的虚函数
18 public:
19     const int DISTANCE = 100;
20 };
21
22 //装饰者 也继承抽象组件 （即抽象组件即可以指向被装饰者，也可以指向装饰者）
23 class Decorator : public Bird{
24 public:
25     Decorator(){}
26
27     Decorator(Bird* bird);
28
29 protected:
30     Bird *myBird; //并且依赖抽组件
31 };
32
33 //具体装饰者
34 class SparrowDecorator : public Decorator{
35 public:
36     SparrowDecorator(Bird *bird);
37     int fly() override;
38 private:
39     int eleFly();
40 public:
41     const int DISTANCE = 50;
42
43 };
44
45 #endif

2、Bird.cpp

 1 #include "Bird.h"
 2
 3 int Sparrow::fly()
 4 {
 5     return DISTANCE;
 6 }
 7
 8
 9 Decorator::Decorator(Bird *bird)
10 {
11     myBird = bird;
12 }
13
14 SparrowDecorator::SparrowDecorator(Bird *bird) :Decorator(bird)
15 {
16 }
17
18 int SparrowDecorator::fly()
19 {
20     int distance = 0;
21     distance = myBird->fly() + eleFly();
22     return distance;
23 }
24
25 int SparrowDecorator::eleFly()
26 {
27     return DISTANCE;
28 }

3、decorator.cpp

 1 #include <iostream>
 2 #include "Bird.h"
 3 using namespace std;
 4
 5 void needBird(Bird *bird)
 6 {
 7     int flyDistance = bird->fly();
 8     cout << "this bird can fly " << flyDistance << "mile" << endl;
 9
10 }
11
12
13 int main()
14 {
15     Bird *sparrow = new Sparrow(); //普通的鸟
16     Bird *sparrowDecorator1 = new SparrowDecorator(sparrow);
17     Bird *sparrowDecorator2 = new SparrowDecorator(sparrowDecorator1);
18     needBird(sparrowDecorator1);
19     needBird(sparrowDecorator2);
20     return 0;
21 }

装饰模式最重要的就是，“具体组件”和“装饰”都是抽象组件的子类，说明抽象组件的对象声明即可以存放“被装饰者”的引用，也可以存放“装饰者的引用”，这样一个“被装饰者”被装饰变为“装饰者”之后，还可以被装饰，即多次装饰。