装饰者模式及C++实现

装饰者模式

时常会遇到这样一种情况，我已经设计好了一个接口，并且也有几个实现类，但是这时我发现我设计的时候疏忽了，忘记了一些功能，或者后来需求变动要求加入一些功能，最简单的做法就是修改接口，添加函数，然后继承类中都相应的添加实现，这样做倒也没什么问题，但是如果这种变化来个好几次或者继承类非常多，那工作量可就大了。

这时大神们就发明了装饰者模式，在不修改现在有接口和实现类的基础上实现功能或者状态的添加。

从类图上看，ConcreteComponent是Component原有的继承类，而Decorator装饰者类也继承与Component，这样的是让Decorator的子类也可以方便的添加Component，而不用每个子类里面都去包含一次Component。（我的理解）

这样客户端使用的时候只需要知道ConcreteDecorator就可以直接调用Decorator的operation方法了，至于operation方法是怎么实现的以及使用的Component的哪一个子类是不需要关心的，而且添加的方法addBehavior也可以直接使用。

客户端就无法依赖于抽象了，如果addBehavior的实现方法要变了，比较好的是添加新的ConcreteDecorator子类，或者继承这个ConcreteDecorator重新实现addBehavior。

常用的情况

如果需要添加新功能，但又不想修改定义好的接口或者抽象类，那么这时候就比较适合装饰模式，例如很多图形系统中的组件，就可以使用装饰模式，来让新的组件在继承现在功能的基础上添加新的功能。

装饰模式一般是针对接口或者抽象类的变化，如果是具体实现类的变化，则要考虑适用哪种模式。

优点

1.可以不用修改原有的接口，就可以实现新功能的添加。

2.装饰者可以很方便的转换原有接口中的实现，可以给装饰者指定不同的ConcreteComponent实现不同的功能。

缺点

1.复杂性增加，装饰者模式会导致许多小类的产生。

C++代码实现

 #ifndef _COMPONENT_H_
 #define _COMPONENT_H_

 class Component
 {
 public:
     Component();
     virtual ~Component();

     virtual void operation() = ;
 };

 class ConcreteComponent: public Component
 {
 public:
     ConcreteComponent();
     ~ConcreteComponent();

     void operation();
 };

 #endif

 #include "Component.h"
 #include <stdio.h>

 Component::Component()
 {

 }

 Component::~Component()
 {

 }

 ConcreteComponent::ConcreteComponent()
 {

 }

 ConcreteComponent::~ConcreteComponent()
 {

 }

 void ConcreteComponent::operation()
 {
     fprintf(stderr, "ConcreteComponent's operation!\n");
 }

 #ifndef _DECORATOR_H_
 #define _DECORATOR_H_

 #include "Component.h"

 class Decorator: public Component
 {
 public:
     Decorator();
     virtual ~Decorator();

     virtual void operation();
     virtual void setComponent(Component* pComponent);

 protected:
     Component* mComponent;
 };

 class ConcreteDecorator: public Decorator
 {
 public:
     ConcreteDecorator();
     virtual ~ConcreteDecorator();

     virtual void addBehavior();
 };

 #endif

Decorator.h

 #include "Decorator.h"
 #include <stdio.h>

 Decorator::Decorator()
 {

 }

 Decorator::~Decorator()
 {

 }

 void Decorator::operation()
 {
     mComponent->operation();
 }

 void Decorator::setComponent(Component* pComponent)
 {
     this->mComponent = pComponent;
 }

 ConcreteDecorator::ConcreteDecorator()
 {

 }

 ConcreteDecorator::~ConcreteDecorator()
 {

 }

 void ConcreteDecorator::addBehavior()
 {
     fprintf(stderr, "ConcreteDecorator's addBehavior!\n");
 }

Decorator.cpp

 #include "Decorator.h"

 int main()
 {
     Component* pComponent = new ConcreteComponent();
     ConcreteDecorator* pConDecorator = new ConcreteDecorator();
     pConDecorator->setComponent(pComponent);
     pConDecorator->operation();
     pConDecorator->addBehavior();
     return ;
 }

client.cpp

 g++ -o client client.cpp Component.cpp Decorator.cpp

运行结果