Decorator 装饰

意图

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

结构

Component:定义一个对象接口，可以给这些对象动态地添加职责；（纯虚函数）

ConcreteComponent:定义一个具体的Component，继承自Component，重写了Component类的虚函数；（继承Component，实现纯虚函数）

Decorator:维持一个指向Component对象的指针，该指针指向需要被装饰的对象；并定义一个与Component接口一致的接口；（继承Component，提供接口（接口就是那个纯虚函数））

ConcreteDecorator:向组件添加职责。（添加具体功能）

实现

 #include <iostream>
 using namespace std;
 class Component
 {
 public:
     virtual void Operation() = ;
 };
 class ConcreteComponent : public Component
 {
 public:
     void Operation()
     {
         cout << "I am no decoratored ConcreteComponent" << endl;
     }
 };
 class Decorator : public Component
 {
 public:
     Decorator(Component *pComponent) : m_pComponentObj(pComponent) {}
     void Operation()
     {
         if (m_pComponentObj != NULL)
         {
             m_pComponentObj->Operation();
         }
     }
 protected:
     Component *m_pComponentObj;
 };
 class ConcreteDecoratorA : public Decorator
 {
 public:
     ConcreteDecoratorA(Component *pDecorator) : Decorator(pDecorator){}
     void Operation()
     {
         AddedBehavior();
         Decorator::Operation();
     }
     void  AddedBehavior()
     {
         cout << "This is added behavior A." << endl;
     }
 };
 class ConcreteDecoratorB : public Decorator
 {
 public:
     ConcreteDecoratorB(Component *pDecorator) : Decorator(pDecorator){}
     void Operation()
     {
         AddedBehavior();
         Decorator::Operation();
     }
     void  AddedBehavior()
     {
         cout << "This is added behavior B." << endl;
     }
 };
 int main()
 {
     Component *pComponentObj = new ConcreteComponent();
     Decorator *pDecoratorAOjb = new ConcreteDecoratorA(pComponentObj);
     pDecoratorAOjb->Operation();
     cout << "=============================================" << endl;
     Decorator *pDecoratorBOjb = new ConcreteDecoratorB(pComponentObj);
     pDecoratorBOjb->Operation();
     cout << "=============================================" << endl;
     Decorator *pDecoratorBAOjb = new ConcreteDecoratorB(pDecoratorAOjb);
     pDecoratorBAOjb->Operation();
     cout << "=============================================" << endl;
     delete pDecoratorBAOjb;
     pDecoratorBAOjb = NULL;
     delete pDecoratorBOjb;
     pDecoratorBOjb = NULL;
     delete pDecoratorAOjb;
     pDecoratorAOjb = NULL;
     delete pComponentObj;
     pComponentObj = NULL;
 }

桥接和装饰的区别

二者都是为了防止过度的继承，从而造成子类泛滥的情况。

桥接模式的定义是将抽象化与实现化分离（用组合的方式而不是继承的方式），使得两者可以独立变化。可以减少派生类的增长。装饰是在一个核心功能上添加一些附属功能，从而让核心功能发挥更大的作用，但是最终它的核心功能是不能丢失的。

桥接模式中所说的分离，其实是指将结构与实现分离（当结构和实现有可能发生变化时）或属性与基于属性的行为进行分离；而装饰者只是对基于属性的行为进行封闭成独立的类，从而达到对其进行装饰，也就是扩展。比如：异常类和异常处理类之间就可以使用桥接模式来实现完成，而不能使用装饰模式来进行设计；如果对于异常的处理需要进行扩展时，我们又可以对异常处理类添加Decorator，从而添加处理的装饰，达到异常处理的扩展，这就是一个桥接模式与装饰模式的搭配；