C++设计模式——结构型模式之装饰器模式（Decorator）

装饰器模式（Decorator）是动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活；装饰模式能够实现动态的为对象添加功能，是从一个对象外部来给对象添加功能。

• Component：定义一个对象的对外接口，将通过这个接口来实现对象动态地添加职责；
• ConcreteComponent：定义一个具体的Component，继承自ConcreateComponent，重写了Component类的虚函数；
• Decorator:维持一个指向Component对象的指针，该指针指向需要被装饰的对象；并实现Component接口；
• ConcreteDecorator:在接口中向组件添加职责

接口的定义：

class Component
{
public:
    virtual void Operation() = 0;
};

ConcreteComponent具体的对象：

class ConcreteComponent : public Component
{
public:
    void Operation()//实现了接口，在不需要扩展时，我们并不需要Decorator
    {
        cout << "ConcreteComponent::Operation" << endl;
    }
};

上面的两步是我们经常使用的形式，通过子类来扩展功能，现在我们希望在ConcreteComponent的Operation再添加一些功能，再不改变ConcreteComponent的实现如何进行，这个时候需要Decorator出场了：通过传入ConcreteComponent来对其进行不可描述的操作，来实现功能的扩展。

class Decorator : public Component
{  //这里还是实现Component的接口来保持接口的一致性
public:
    Decorator(Component *pComponent) : m_pComponentObj(pComponent) {}
    void Operation()
    {
        if (m_pComponentObj != NULL)
        {
            m_pComponentObj->Operation();//执行对象的原始操作
        }
    }
protected:
    Component *m_pComponentObj;//记录传入的对象
};

上面的Decorator并未做任何的扩展功能，它是装饰器的基类，具体的实现通过子类来完成：

class ConcreteDecoratorA : public Decorator
{
public:
    ConcreteDecoratorA(Component *pDecorator) : Decorator(pDecorator) {}
    void Operation()
    {     //这里进行功能的扩展，添加了AddedBehavior功能
        AddedBehavior();
        Decorator::Operation(); //执行原始的操作
    }
    void  AddedBehavior()
    {
        cout << "This is added behavior A." << endl;
    }
};

通过子类ConcreteDecoratorA，我们扩展了原始对象m_pComponentObj的功能，来看下我们如何调用扩展之后的功能：

int main()
{
    Component *pComponentObj = new ConcreteComponent();//创建原始对象

    //将原始对象传入实现扩展功能的Decorator子类
    Decorator *pDecoratorAOjb = new ConcreteDecoratorA(pComponentObj);

    //执行实现扩展的ConcreteDecoratorA的Operation，
    //这里解释了我们为什么要在装饰器中去实现Component的接口，来不去重新定义一个新的接口
    pDecoratorAOjb->Operation();

    delete pDecoratorAOjb;
    pDecoratorAOjb = NULL;
    delete pComponentObj;
    pComponentObj = NULL;
}

完整源码:

#include 
using namespace std;

class Component
{
public:
	virtual void Operation() = 0;
};

class ConcreteComponent : public Component
{
public:
	void Operation()
	{
		cout << "ConcreteComponent::Operation" << 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;
	}
};

int main()
{
	Component *pComponentObj = new ConcreteComponent();
	Decorator *pDecoratorAOjb = new ConcreteDecoratorA(pComponentObj);
	pDecoratorAOjb->Operation();

	delete pDecoratorAOjb;
	pDecoratorAOjb = NULL;
	delete pComponentObj;
	pComponentObj = NULL;
}