(C++设计模式) ------Decorator装饰模式-- 结构型模式

(C++设计模式) ------装饰模式-- 结构型模式

设计模式的学习是一个循序渐进的过程，每一个设计师都是在套用这几种设计模式来实现自己的软件构架，很多都是融合会贯通的，一个设计模式中不仅仅是用到一种，所以要灵活运用这些设计模式。理解了设计模式对设计和代码的阅读都有很大的好处！！

今天我们学习结构性模式装饰（Decorator）模式.

装饰者模式：是动态的给已知的对象动态的添加额外的功能，但是又不影响对象已有的功能。仅仅对增加子类来说，装饰者模式比继承生成子类更加灵活，原因是装饰者模式可以根据功能需要有用户动态决定加入的方式和时机，实现“即插即用”的功能，在运行时动态决定增加何种功能；通过继承生成子类是一种静态的实现方法。

为什么不用继承而用组合呢？
原因是：

①  如果要增加的功能比较多，则继承会生成很多的子类。
② 使用继承，则新的功能是在编译器就决定了的。而更多的时刻我们更愿意在运行期时指定新的功能。即由用户动态指定。
Decorator看起来和Composite很像。但是，很明显，Composite模式更强调的是层次关系，即Panel与Component的关系。

Decorator装饰设计模式中的两种角色：

Decoratee被装饰者：即需要功能增强的原始对象，即目标对象ConcreteComponent的对象。

Decorator装饰者：为原始对象提供功能增强的对象。

抽象基类：
1） Component ：定义一个对象接口，可以为这个接口动态地添加职责。
2） Decorator：维持一个指向Component的指针，并且有一个和Component一致的接口函数。

客户类：和集体的被装饰者关联；

接口函数：
Component::Operation：这个接口函数由Component声明，因此Component的派生类都需要实现，可以在这个接口函数的基础上给它动态添加职责。

具体实现的解析：

这个模式的主要宗旨：是用装饰者的派生类动态地根据被装饰者的对象的需求去装饰被装饰者 即ConcreateComponent类的对象。

①  首先是ConcreateComponent和Decorator同时继承Component；

②  Decorator类维护一个protected类型的Component的指针，（这里用到的是组合的模式）作为Decorator类的数据成员。同时用Component的指针作为自己的构造函数的参数。指针是protected类型的原因是：派生类继承之后就是他们私有的数据成员。

③  Decorator类的派生类用Component的指针作为自己的构造函数的参数，目的是用来初始化父类的protected类型的Component的指针，以便动态调用被装饰类集体对象的已有的功能。

④  应用的时候，首先要new一个ConcreteComponent的对象，然后把对象传递给Decorator的派生类作为参数，让他们给这个对象添加职责。

 

代码演示： #include "stdafx.h" #include "iostream" #include using namespace std; // 抽象基类，定义一个对象接口，可以为这个接口动态地添加职责 class Component { public: virtual ~Component(); virtual void Operation() = 0; protected: Component(); }; //ConcreteDecorator：具体的Component对象，可以给该对象动态添加职责 class ConcreteComponent:public Component { public: ConcreteComponent(); ~ConcreteComponent(); virtual void Operation(); }; //Decorator：装饰抽象类，继承自Component class Decorator:public Component { public: Decorator(Component* com); virtual ~Decorator(); virtual void Operation(); protected: Component* _com; }; //ConcreteDecorator就是具体的装饰对象之一，起到给Component添加职责的功能 class ConcreteDecoratorA: public Decorator { public: ConcreteDecoratorA(Component* com); ~ConcreteDecoratorA(); virtual void Operation(); private: void AddedState(); }; //ConcreteDecorator就是具体的装饰对象之二，起到给Component添加职责的功能 class ConcreteDecoratorB:public Decorator { public: ConcreteDecoratorB(Component* com); ~ConcreteDecoratorB(); virtual void Operation(); private: void AddedBehavor(); }; //cpp //#include "Decorator.h" #include using namespace std; //Component Component::Component() {} Component::~Component() { cout << "~Component" << endl; } //ConcreteComponent ConcreteComponent::ConcreteComponent() {} ConcreteComponent::~ConcreteComponent() { cout << "~ConcreteComponent" << endl; } void ConcreteComponent::Operation() { cout << "-------------------" << endl; cout << "原职责：ConcreteComponent::Operation" << endl; } //Decorator Decorator::Decorator(Component* com) { this->_com = com; } Decorator::~Decorator() { cout << "~Decorator" << endl; delete this->_com; this->_com = NULL; } void Decorator::Operation() { cout << "Decorator::Operation" << endl; } //ConcreteDecoratorA ConcreteDecoratorA::ConcreteDecoratorA(Component* com):Decorator(com) { } ConcreteDecoratorA::~ConcreteDecoratorA() { cout << "~ConcreteDecoratorA" << endl; } void ConcreteDecoratorA::Operation() { this->_com->Operation(); //附加职责A this->AddedState(); } void ConcreteDecoratorA::AddedState() { cout << "附加职责A：ConcreteDecoratorA::AddedState" << endl; } //ConcreteDecoratorB ConcreteDecoratorB::ConcreteDecoratorB(Component* com):Decorator(com) {} ConcreteDecoratorB::~ConcreteDecoratorB() { cout << "~ConcreteDecoratorB" << endl; } void ConcreteDecoratorB::Operation() { this->_com->Operation(); //附加职责B this->AddedBehavor(); } void ConcreteDecoratorB::AddedBehavor() { cout << "附加职责B：ConcreteDecoratorB::AddedBehavor" << endl; }

 调用方式一： int _tmain(int argc, _TCHAR* argv[]) { Component* pCom = new ConcreteComponent(); //要装饰的对象 Decorator* pDec = NULL; //给装饰对象附加职责A pDec = new ConcreteDecoratorA(pCom); pDec->Operation(); //给装饰对象附加职责B pDec = new ConcreteDecoratorB(pCom); pDec->Operation(); cout << "----------------析构---------------" << endl; delete pDec; cout << "-------------------------------" << endl; return 0; }

结果：ConcreteComponent()传入的参数两次一样。

 调用方式二： int _tmain(int argc, _TCHAR* argv[]) { Component* pCom = new ConcreteComponent(); //要装饰的对象 Decorator* pDec = NULL; //给装饰对象附加职责A pDec = new ConcreteDecoratorA(pCom); //给装饰对象附加职责B pDec = new ConcreteDecoratorB(pDec); pDec->Operation(); cout << "----------------析构---------------" << endl; delete pDec; cout << "-------------------------------" << endl; return 0; }

结果：ConcreteComponent()传入的参数两次不一样。

第二种调用方法pDec = new ConcreteDecoratorB(pDec); 其中是ConcreteDecoratorB(pDec)是把pDec从ConcreteDecoratorA *隐藏转化成Component*，

pDec->Operation();去调用函数

void ConcreteDecoratorB::Operation()
{
    this->_com->Operation();
    //附加职责B
    this->AddedBehavor();
}

的时候this->_com就是ConcreteDecoratorA*已经不是动态多态实现的了。

这种理解纯属个人理解。