第八個設計模式

意圖
動態地給一個物件新增一些額外的職責。有時候我們需要給某個物件而不是整個類新增一些功能。

適用性

• 在不影響其他物件的情況下，以動態、透明的方式給單個物件新增職責。
• 處理那些可以撤消的職責。
• 當不能採用生成子類的方法進行擴充時。一種情況是，可能有大量獨立的擴充套件，
• 為支援每一種組合將產生大量的子類，使得子類數目呈爆炸性增長。另一種情況可能是因為類定義被隱藏，或類定義不能用於生成子類。

結構

參與者
Component：定義一個物件介面，可以給這些物件動態地新增職責。

ConcreteComponent： 定義一個物件，可以給這個類的物件新增一些職責

Decorator:維持一個指向Component物件的指標，並定義一個與Component介面一致的介面

ConcreteDecorator:向元件新增職責。

實現

#include <string>  
#include <iostream>  
#include <memory>  
using namespace std;  

//抽象類Tank  
class Tank  
{  
public:  
    virtual void shot()=0;  
    virtual void run()=0;  

public:  
    virtual ~Tank()  
    {  
        cout<<"in the destructor of Tank"
 
<<endl;  
    }     
};  
//具體類 T50  
class T50:public Tank  
{  
public:  
    void shot()  
    {  
        cout<<"Tank T50 shot()"<<endl;  
    }  
    void run()  
    {  
        cout<<"Tank T50 run()"<<endl;  
    }  
public:  
    virtual ~T50()  
    {  
        cout<<"In the destructor of T50"
 
<<endl;  
    }  
};  
//具體類T75  
class T75:public Tank  
{  
public:  
    void shot()  
    {  
        cout<<"Tank T75 shot()"<<endl;  
    }  
    void run()  
    {  
        cout<<"Tank T75 run()"<<endl;  
    }  
public:  
    virtual ~T75()  
    {  
        cout<<"In the destructor of T75"<<endl;  
    }  
};  

//抽象類，Decorator  
class Decorator:public Tank  
{  
protected:  
    Tank* tank;  
public:  
    Decorator(Tank* tank):tank(tank) {}  //具體的坦克的裝飾類  
    virtual ~Decorator()  
    {  
        cout<<"In the destructor of Decorator"<<endl;  
    }  
public:  
    void shot()  
    {  
        tank->shot();  
    }  
    void run()  
    {  
        tank->run();  
    }  
};  

class InfraredDecorator: public Decorator  
{  
private:  
    string infrared;//這就是所謂的addAtrribute  
public:  
    InfraredDecorator(Tank* tank):Decorator(tank) {}  
    virtual ~InfraredDecorator()  
    {  
        cout<<"in the destructor of InfraredDecorator"<<endl;  
    }  
public:  
    void set_Infrared(const string &infrared)  
    {  
        this->infrared=infrared;  
    }  
    string get_infrared() const  
    {  
        return infrared;  
    }  
    void run()  
    {  
        tank->run();  
        set_Infrared("+Infrared");  
        cout<<get_infrared()<<endl;  
    }  
    void shot()  
    {  
        tank->shot();  
    }  
};  

class AmphibianDecorator:public Decorator  
{  
private:  
    string amphibian;  
public:  
    AmphibianDecorator(Tank* tank):Decorator(tank) {}  
    ~AmphibianDecorator()  
    {  
        cout<<"in the destructor of AmphibianDecorator"<<endl;  
    }  
public:  
    void set_amphibian(const string &hibian)  
    {  
        this->amphibian=hibian;  
    }  
    string get_amphibian() const  
    {  
        return amphibian;  
    }  
public:  
    void run()  
    {  
        tank->run();  
        set_amphibian("+amphibian");  
        cout<<get_amphibian()<<endl;  
    }  
    void shot()  
    {  
        tank->shot();  
    }  
};  

int main(int argc, char **argv)  
{  
    //給T50增加紅外功能  
    Tank* tank1(new T50);  
    Tank* pid1(new InfraredDecorator(tank1));  
    pid1->shot();  
    cout<<endl;  
    pid1->run();  
    cout<<endl;  
    cout<<endl<<"---------------"<<endl;  
    //給t75增加紅外、兩棲功能  
    Tank* tank2(new T75);  
    tank2->run();  
    Tank* pid2(new InfraredDecorator(tank2));  
    Tank* pad2(new AmphibianDecorator(pid2));  
    pad2->shot();  
    cout<<endl;  
    pad2->run();  
    cout<<endl;  
    cout<<endl<<"--------------"<<endl;  

    //動態撤銷其他裝飾 ?  
    tank2->run();  

    Tank * tank3(tank2);  
    tank3->run();  
    return 0;  
}  

適用場景與優缺點：

在以下情況下應當使用裝飾模式：
1.需要擴充套件一個類的功能，或給一個類增加附加責任。
2.需要動態地給一個物件增加功能，這些功能可以再動態地撤銷。
3.需要增加由一些基本功能的排列組合而產生的非常大量的功能，從而使繼承關係變得不現實。

優點：
1. Decorator模式與繼承關係的目的都是要擴充套件物件的功能，但是Decorator可以提供比繼承更多的靈活性。
2. 通過使用不同的具體裝飾類以及這些裝飾類的排列組合，設計師可以創造出很多不同行為的組合。

缺點：
1. 這種比繼承更加靈活機動的特性，也同時意味著更加多的複雜性。
2. 裝飾模式會導致設計中出現許多小類，如果過度使用，會使程式變得很複雜。
3. 裝飾模式是針對抽象元件（Component）型別程式設計。但是，如果你要針對具體元件程式設計時，就應該重新思考你的應用架構，以及裝飾者是否合適。當然也可以改變Component介面，增加新的公開的行為，實現“半透明”的裝飾者模式。在實際專案中要做出最佳選擇。