设计模式之装饰模式(Decorator)

装饰模式是一种经典的类功能扩展模式，其精髓在装饰类使用继承加聚合的方式得到接口和要实现对象，而后经过本身实现扩展接口

做用

装饰模式经过装饰类动态地将责任附加到对象上，若要扩展功能，无需经过继承增长子类就能扩展对象的新功能，提供了比继承更有弹性的替代方案，避免了子类数量膨胀带来的系统臃肿。

类视图

代码实现

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

    virtual void operation() = 0;
};


class ConcreteComponentA : public Component
{
public:
    ConcreteComponentA(){}
    ~ConcreteComponentA(){}

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

class ConcreteComponentB : public Component
{
public:
    ConcreteComponentB(){}
    ~ConcreteComponentB(){}

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

class Decorator : public Component
{
public:
    Decorator() :mComponent(NULL){}
    virtual ~Decorator(){}

    virtual void operation()
    {
        if (mComponent)
            mComponent->operation();
    }
    virtual void setComponent(Component* pComponent)
    {
        mComponent = pComponent;
    }

protected:
    Component* mComponent;
};


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

    virtual void addBehavior()
    {
        mComponent->operation();
        fprintf(stderr, "ConcreteDecoratorE's addBehavior!\n");
    }
};

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

    virtual void addBehavior()
    {
        operation();
        fprintf(stderr, "ConcreteDecoratorF's addBehavior!\n");
    }
};



int main()
{
    ConcreteComponentB *pComponent = new ConcreteComponentB();
    ConcreteDecoratorF decorator;
    decorator.setComponent(pComponent);
    decorator.addBehavior();
}