C++設計模式-Decorator裝飾模式

Decorator裝飾模式
作用：動態地給一個對象添加一些額外的職責，就增加功能來說，裝飾模式比生成子類更為靈活。

UML圖如下：

Component是定義一個對象接口，可以給這些對象動態地添加職責。

ConcreteComponent是定義了一個具體的對象，也可以給這個對象添加一些職責。
Decorator，裝飾抽象類，繼承了Component，從外類來擴展Component類的功能，但對於Component來說，是無需知道Decorator的存在的。
至於ConcreteDecorator就是具體的裝飾對象，起到給Component添加職責的功能。

要善於變通，如果只有一個ConcreteComponent類而沒有抽象的Component類，那么Decorator類可以是ConcreteComponent的一個子類。
同樣道理，如果只有一個ConcreteDecorator類，那么就沒有必要建立一個單獨的Decorator類，而可以把Decorator和ConcreteDecorator的責任合並成一個類。

新加入的東西僅僅是為了滿足一些只在某種特定情況下才會執行的特殊行為 的需要。而裝飾模式卻提供了一個非常好的解決方案，它把每個要裝飾的功能放在單獨的類中，並讓這個類包裝它所要裝飾的對象，因此，當需要執行特殊行為 時，客戶代碼就可以在運行時根據需要有選擇地、按順序地使用裝飾功能包裝對象了。

代碼如下：

Decorator.h

#ifndef _DECORATOR_H_
#define _DECORATOR_H_

//Component抽象類，定義該類對象的接口
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);
    void SetComponent(Component* com);
    virtual ~Decorator();
    virtual void Operation();
protected:
    Component* _com;
};

//ConcreteDecorator就是具體的裝飾對象之一，起到給Component添加職責的功能
class ConcreteDecoratorA:public Decorator
{
public:
    ConcreteDecoratorA(Component* com);
    ~ConcreteDecoratorA();
    virtual void Operation();
    void AddBehavorA();
};

//ConcreteDecorator就是具體的裝飾對象之二，起到給Component添加職責的功能
class ConcreteDecoratorB:public Decorator
{
public:
    ConcreteDecoratorB(Component* com);
    ~ConcreteDecoratorB();
    virtual void Operation();
    void AddBehavorB();
};

//ConcreteDecorator就是具體的裝飾對象之三，起到給Component添加職責的功能
class ConcreteDecoratorC:public Decorator
{
public:
    ConcreteDecoratorC(Component* com);
    ~ConcreteDecoratorC();
    virtual void Operation();
    void AddBehavorC();
};

//ConcreteDecorator就是具體的裝飾對象之四，起到給Component添加職責的功能
class ConcreteDecoratorD:public Decorator
{
public:
    ConcreteDecoratorD(Component* com);
    ~ConcreteDecoratorD();
    virtual void Operation();
    void AddBehavorD();
};

//只添加一種裝飾，則不用抽象出裝飾基類
class DecoratorOnlyOne:public Component
{
public:
    DecoratorOnlyOne(Component* com);
    ~DecoratorOnlyOne();
    virtual void Operation();
    void AddBehavor();
private:
    Component* _com;
};

//如果只有一個ConcreteComponent類而沒有抽象的Component類，那么Decorator類可以是ConcreteComponent的一個子類。
//略
#endif

Decorator.cpp

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

using namespace std;

Component::Component()
{}

Component::~Component()
{
    cout << "~Component" << endl;
}

ConcreteComponent::ConcreteComponent()
{}

ConcreteComponent::~ConcreteComponent()
{
    cout << "~ConcreteComponent" << endl;
}

void ConcreteComponent::Operation()
{
    cout << "原職責：ConcreteComponent::Operation" << endl;
}

Decorator::Decorator(Component* com)
{
    this->_com = com;
}

void Decorator::SetComponent(Component* com)
{
    this->_com = com;
}

Decorator::~Decorator()
{
    cout << "~Decorator" << endl;
    delete this->_com;
    this->_com = NULL;
}

void Decorator::Operation()
{}

ConcreteDecoratorA::ConcreteDecoratorA(Component* com):Decorator(com)
{}

ConcreteDecoratorA::~ConcreteDecoratorA()
{
    cout << "~ConcreteDecoratorA" << endl;
}

void ConcreteDecoratorA::Operation()
{
    this->_com->Operation();
    //附加職責A
    this->AddBehavorA();
}

void ConcreteDecoratorA::AddBehavorA()
{
    cout << "附加職責A：ConcreteDecoratorA::AddBehavorA" << endl;
}

ConcreteDecoratorB::ConcreteDecoratorB(Component* com):Decorator(com)
{}

ConcreteDecoratorB::~ConcreteDecoratorB()
{
    cout << "~ConcreteDecoratorB" << endl;
}

void ConcreteDecoratorB::Operation()
{
    this->_com->Operation();
    //附加職責B
    this->AddBehavorB();
}

void ConcreteDecoratorB::AddBehavorB()
{
    cout << "附加職責B：ConcreteDecoratorB::AddBehavorB" << endl;
}

ConcreteDecoratorC::ConcreteDecoratorC(Component* com):Decorator(com)
{}

ConcreteDecoratorC::~ConcreteDecoratorC()
{
    cout << "~ConcreteDecoratorC" << endl;
}

void ConcreteDecoratorC::Operation()
{
    this->_com->Operation();
    //附加職責C
    this->AddBehavorC();
}

void ConcreteDecoratorC::AddBehavorC()
{
    cout << "附加職責C：ConcreteDecoratorC::AddBehavorC" << endl;
}

ConcreteDecoratorD::ConcreteDecoratorD(Component* com):Decorator(com)
{}

ConcreteDecoratorD::~ConcreteDecoratorD()
{
    cout << "~ConcreteDecoratorD" << endl;
}

void ConcreteDecoratorD::Operation()
{
    this->_com->Operation();
    //附加職責D
    this->AddBehavorD();
}

void ConcreteDecoratorD::AddBehavorD()
{
    cout << "附加職責D：ConcreteDecoratorD::AddBehavorD" << endl;
}

//**************只添加一種修飾******************
DecoratorOnlyOne::DecoratorOnlyOne(Component* com):_com(com)
{
}

DecoratorOnlyOne::~DecoratorOnlyOne()
{
    cout << "~DecoratorOnlyOne" << endl;
    delete this->_com;
    this->_com = NULL;
}

void DecoratorOnlyOne::Operation()
{
    this->_com->Operation();
    this->AddBehavor();
}

void DecoratorOnlyOne::AddBehavor()
{
    cout << "附加唯一職責：DecoratorOnlyOne::AddBehavor" << endl;
}

main.cpp

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

using namespace std;
int main()
{
    Component* pCom = new ConcreteComponent();        //要裝飾的對象
    Decorator* pDec = NULL;
    pDec = new ConcreteDecoratorA(pCom);            //給裝飾對象附加職責A
    pDec = new ConcreteDecoratorB(pDec);            //給裝飾對象附加職責B
    pDec = new ConcreteDecoratorC(pDec);            //給裝飾對象附加職責C
    pDec = new ConcreteDecoratorD(pDec);            //給裝飾對象附加職責D
    pDec->Operation();

    cout << "-------------------------------" << endl;

    //只添加一種修飾
    Component* pCom1 = new ConcreteComponent();
    DecoratorOnlyOne* pDec1 = new DecoratorOnlyOne(pCom1);
    pDec1->Operation();

    cout << "-------------------------------" << endl;

    delete pDec;
    cout << "-------------------------------" << endl;

    delete pDec1;

    return 0;
}

運行結果：

　　　　　　　　　

Decorator模式除了采用組合的方式取得了比采用繼承方式更好的效果，Decorator模式還給設計帶來一種“即用即付”的方式來添加職責。在OO設計和分析經常有這樣一種情況：為了多態，通過父類指針指向其具體子類，但是這就帶來另外一個問題，當具體子類要添加新的職責，就必須向其父類添加一個這個職責的抽象接口，否則是通過父類指針是調用不到這個方法了。這樣處於高層的父類就承載了太多的特征（方法），並且繼承自這個父類的所有子類都不可避免繼承了父類的這些接口，但是可能這並不是這個具體子類所需要的。而在Decorator模式提供了一種較好的解決方法，當需要添加一個操作的時候就可以通過Decorator模式來解決，你可以一步步添加新的職責。