2. 程式人生 > >c++ 設計模式6 （Decorator 裝飾模式）

c++ 設計模式6 （Decorator 裝飾模式）

阿新 • • 發佈：2017-06-01
ces 軟件組件 類繼承 通過 write height cte 中間 類型

4. “單一職責”類模式

在軟件組件的設計中，如果責任劃分的不清晰，使用繼承得到的結果往往是隨著需求的變化，子類急劇膨脹，同時充斥著重復代碼，這時候的關鍵是劃清責任。

典型模式代表： Decorator，Bridge

4.1 Decorator 裝飾模式

代碼示例：不同的流操作（文件流，網絡流，內存流）及其擴展功能（加密，緩沖）等的實現

實現代碼1：

類圖結構示意（大量使用繼承）

技術分享

數據規模： 假設有n種文件，m種功能操作。該實現方法有（1 + n + n * m! / 2） 數量級的子類；

同時考察59行，79行，98行本身是相同的代碼（類似還有很多），存在大量的冗余和重復。

開始重構，見方法2.

技術分享 
  1 //Decorator1.cpp
  2 //業務操作
  3 class Stream{
  4 public：
  5     virtual char Read(int number)=0;
  6     virtual void Seek(int position)=0;
  7     virtual void Write(char data)=0;
  8     
  9     virtual ~Stream(){}
 10 };
 11 
 12 //主體類
 13 class FileStream: public Stream{
 14 public:
 15     virtual char Read(int number){
 16         //讀文件流
 17     }
 18     virtual void Seek(int position){
 19         //定位文件流
 20     }
 21     virtual void Write(char data){
 22         //寫文件流
 23     }
 24 
 25 };
 26 
 27 class NetworkStream :public Stream{
 28 public:
 29     virtual char Read(int number){
 30         //讀網絡流
 31     }
 32     virtual void Seek(int position){
 33         //定位網絡流
 34     }
 35     virtual void Write(char data){
 36         //寫網絡流
 37     }
 38     
 39 };
 40 
 41 class MemoryStream :public Stream{
 42 public:
 43     virtual char Read(int number){
 44         //讀內存流
 45     }
 46     virtual void Seek(int position){
 47         //定位內存流
 48     }
 49     virtual void Write(char data){
 50         //寫內存流
 51     }
 52     
 53 };
 54 
 55 //擴展操作
 56 class CryptoFileStream :public FileStream{
 57 public:
 58     virtual char Read(int number){
 59        
 60         //額外的加密操作...
 61         FileStream::Read(number);//讀文件流
 62         
 63     }
 64     virtual void Seek(int position){
 65         //額外的加密操作...
 66         FileStream::Seek(position);//定位文件流
 67         //額外的加密操作...
 68     }
 69     virtual void Write(byte data){
 70         //額外的加密操作...
 71         FileStream::Write(data);//寫文件流
 72         //額外的加密操作...
 73     }
 74 };
 75 
 76 class CryptoNetworkStream : :public NetworkStream{
 77 public:
 78     virtual char Read(int number){
 79         
 80         //額外的加密操作...
 81         NetworkStream::Read(number);//讀網絡流
 82     }
 83     virtual void Seek(int position){
 84         //額外的加密操作...
 85         NetworkStream::Seek(position);//定位網絡流
 86         //額外的加密操作...
 87     }
 88     virtual void Write(byte data){
 89         //額外的加密操作...
 90         NetworkStream::Write(data);//寫網絡流
 91         //額外的加密操作...
 92     }
 93 };
 94 
 95 class CryptoMemoryStream : public MemoryStream{
 96 public:
 97     virtual char Read(int number){
 98         
 99         //額外的加密操作...
100         MemoryStream::Read(number);//讀內存流
101     }
102     virtual void Seek(int position){
103         //額外的加密操作...
104         MemoryStream::Seek(position);//定位內存流
105         //額外的加密操作...
106     }
107     virtual void Write(byte data){
108         //額外的加密操作...
109         MemoryStream::Write(data);//寫內存流
110         //額外的加密操作...
111     }
112 };
113 
114 class BufferedFileStream : public FileStream{
115     //...
116 };
117 
118 class BufferedNetworkStream : public NetworkStream{
119     //...
120 };
121 
122 class BufferedMemoryStream : public MemoryStream{
123     //...
124 }
125 
126 
127 
128 
129 class CryptoBufferedFileStream :public FileStream{
130 public:
131     virtual char Read(int number){
132         
133         //額外的加密操作...
134         //額外的緩沖操作...
135         FileStream::Read(number);//讀文件流
136     }
137     virtual void Seek(int position){
138         //額外的加密操作...
139         //額外的緩沖操作...
140         FileStream::Seek(position);//定位文件流
141         //額外的加密操作...
142         //額外的緩沖操作...
143     }
144     virtual void Write(byte data){
145         //額外的加密操作...
146         //額外的緩沖操作...
147         FileStream::Write(data);//寫文件流
148         //額外的加密操作...
149         //額外的緩沖操作...
150     }
151 };
152 
153 
154 
155 void Process(){
156 
157         //編譯時裝配
158     CryptoFileStream *fs1 = new CryptoFileStream();
159 
160     BufferedFileStream *fs2 = new BufferedFileStream();
161 
162     CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();
163 
164 }
技術分享

實現代碼2：

針對上述代碼，重構步驟如下：

1）考察 CryptoFileStream ，CryptoNetworkStream，CryptoMemoryStream三個類，將其繼承FileStream，NetworkStream，NetworkStream改為組合；即

技術分享 
 1 class CryptoFileStream{
 2     FileStream* stream;
 3 public:
 4     virtual char Read(int number){
 5        
 6         //額外的加密操作...
 7         stream -> Read(number);//改用字段方式調用Read()
 8         // ...seek() write() 同理
 9     }
10 }    
11 
12 class CryptoNetworkStream{
13     NetworkStream* stream;
14 public:
15     virtual char Read(int number){
16         
17         //額外的加密操作...
18         stream -> Read(number);//改用字段方式調用Read()
19         //... seek() write() 同理
20     }
21 }    
22 
23 class CryptoMemoryStream{
24     MemoryStream* stream;
25 public:
26     virtual char Read(int number){
27         
28         //額外的加密操作...
29         stream -> Read(number);//改用字段方式調用Read()
30         //... seek() write() 同理
31     }
32 }
技術分享

2）考察上述2行， 13行， 24行， 發現其均為Stream子類， 應使用多態性繼續重構。

技術分享 
 1 class CryptoFileStream{
 2     Stream* stream; // = new FileStream()
 3 public:
 4     virtual char Read(int number){
 5        
 6         //額外的加密操作...
 7         stream -> Read(number);//改用字段方式調用Read()
 8         // ...seek() write() 同理
 9     }
10 }    
11 
12 class CryptoNetworkStream{
13     Stream* stream; // = new NetworkStream();
14 public:
15     virtual char Read(int number){
16         
17         //額外的加密操作...
18         stream -> Read(number);//改用字段方式調用Read()
19         //... seek() write() 同理
20     }
21 }    
22 
23 class CryptoMemoryStream{
24     Stream* stream; // = newMemoryStream()
25 public:
26     virtual char Read(int number){
27         
28         //額外的加密操作...
29         stream -> Read(number);//改用字段方式調用Read()
30         //... seek() write() 同理
31     }
32 }
技術分享

3）發現三個類是相同的，不同的實現（需求的變化）是在運行時實現，編譯時復用，改為一個類即可，命名為CryptoStream。

同時為了保證接口規範（read,seek等仍然是虛函數），繼承Stream,出現既有組合，又有繼承的情況。

技術分享 
 1 class CryptoStream : public Stream{
 2     Stream* stream; // = new ...
 3 public:
 4     virtual char Read(int number){
 5        
 6         //額外的加密操作...
 7         stream -> Read(number);//改用字段方式調用Read()
 8         // ...seek() write() 同理
 9     }
10 }
技術分享

4）添加相應構造器，得到此輪重構後的結果，代碼如下，主要查看使用方式（運行時裝配）：

技術分享 
  1 //Decorator2.cpp
  2 class Stream{
  3 
  4 public：
  5     virtual char Read(int number)=0;
  6     virtual void Seek(int position)=0;
  7     virtual void Write(char data)=0;
  8     
  9     virtual ~Stream(){}
 10 };
 11 
 12 //主體類
 13 class FileStream: public Stream{
 14 public:
 15     virtual char Read(int number){
 16         //讀文件流
 17     }
 18     virtual void Seek(int position){
 19         //定位文件流
 20     }
 21     virtual void Write(char data){
 22         //寫文件流
 23     }
 24 
 25 };
 26 
 27 class NetworkStream :public Stream{
 28 public:
 29     virtual char Read(int number){
 30         //讀網絡流
 31     }
 32     virtual void Seek(int position){
 33         //定位網絡流
 34     }
 35     virtual void Write(char data){
 36         //寫網絡流
 37     }
 38     
 39 };
 40 
 41 class MemoryStream :public Stream{
 42 public:
 43     virtual char Read(int number){
 44         //讀內存流
 45     }
 46     virtual void Seek(int position){
 47         //定位內存流
 48     }
 49     virtual void Write(char data){
 50         //寫內存流
 51     }
 52     
 53 };
 54 
 55 //擴展操作
 56 
 57 
 58 class CryptoStream: public Stream {
 59     
 60     Stream* stream;//...
 61 
 62 public:
 63     CryptoStream(Stream* stm):stream(stm){
 64     
 65     }
 66     
 67     
 68     virtual char Read(int number){
 69        
 70         //額外的加密操作...
 71         stream->Read(number);//讀文件流
 72     }
 73     virtual void Seek(int position){
 74         //額外的加密操作...
 75         stream::Seek(position);//定位文件流
 76         //額外的加密操作...
 77     }
 78     virtual void Write(byte data){
 79         //額外的加密操作...
 80         stream::Write(data);//寫文件流
 81         //額外的加密操作...
 82     }
 83 };
 84 
 85 
 86 
 87 class BufferedStream : public Stream{
 88     
 89     Stream* stream;//...
 90     
 91 public:
 92     BufferedStream(Stream* stm):stream(stm){
 93         
 94     }
 95     //...
 96 };
 97 
 98 
 99 
100 
101 
102 void Process(){
103 
104     //運行時裝配
105     FileStream* s1=new FileStream();
106     CryptoStream* s2=new CryptoStream(s1);
107     
108     BufferedStream* s3=new BufferedStream(s1);
109     
110     BufferedStream* s4=new BufferedStream(s2);
111     
112     
113 
114 }
技術分享

實現代碼3：

上述實現代碼2已經極大地緩解了冗余問題，符合面向對象的設計思想，該輪重構是錦上添花。

重構步驟如下：

考察上述代碼，多個子類都有同樣的字段（Stream* stream;//...）

應考慮“往上提”，方法有兩種，第一種是提到基類（顯然不合適，FileStream等並不需要Stream字段 ）

所以考慮第二種方法，實現一個“中間類”。

技術分享 
DecoratorStream: public Stream{
protected:
    Stream* stream;//...
    
    DecoratorStream(Stream * stm):stream(stm){
    
    }
    
};
技術分享

CryptoStream等繼承中間類DecoratorStream:

技術分享 
class CryptoStream: public DecoratorStream {
 
public:
    CryptoStream(Stream* stm):DecoratorStream(stm){
    
    }
    //...
}
技術分享

重構完成的最終版本：

FileStream,NetworkStream,MemoryStream等可以創建各自的對象；

但實現加密，緩存功能必須在已有FileStream/NetworkStream等對象基礎上；

這些操作本質是擴展操作，也就是“裝飾”的含義。

此時類圖示意：

這時類的數量為（1 + n + 1 + m）

技術分享

技術分享 
  1 //Decorator3.cpp
  2 class Stream{
  3 
  4 public：
  5     virtual char Read(int number)=0;
  6     virtual void Seek(int position)=0;
  7     virtual void Write(char data)=0;
  8     
  9     virtual ~Stream(){}
 10 };
 11 
 12 //主體類
 13 class FileStream: public Stream{
 14 public:
 15     virtual char Read(int number){
 16         //讀文件流
 17     }
 18     virtual void Seek(int position){
 19         //定位文件流
 20     }
 21     virtual void Write(char data){
 22         //寫文件流
 23     }
 24 
 25 };
 26 
 27 class NetworkStream :public Stream{
 28 public:
 29     virtual char Read(int number){
 30         //讀網絡流
 31     }
 32     virtual void Seek(int position){
 33         //定位網絡流
 34     }
 35     virtual void Write(char data){
 36         //寫網絡流
 37     }
 38     
 39 };
 40 
 41 class MemoryStream :public Stream{
 42 public:
 43     virtual char Read(int number){
 44         //讀內存流
 45     }
 46     virtual void Seek(int position){
 47         //定位內存流
 48     }
 49     virtual void Write(char data){
 50         //寫內存流
 51     }
 52     
 53 };
 54 
 55 //擴展操作
 56 
 57 DecoratorStream: public Stream{
 58 protected:
 59     Stream* stream;//...
 60     
 61     DecoratorStream(Stream * stm):stream(stm){
 62     
 63     }
 64     
 65 };
 66 
 67 class CryptoStream: public DecoratorStream {
 68  
 69 
 70 public:
 71     CryptoStream(Stream* stm):DecoratorStream(stm){
 72     
 73     }
 74     
 75     
 76     virtual char Read(int number){
 77        
 78         //額外的加密操作...
 79         stream->Read(number);//讀文件流
 80     }
 81     virtual void Seek(int position){
 82         //額外的加密操作...
 83         stream::Seek(position);//定位文件流
 84         //額外的加密操作...
 85     }
 86     virtual void Write(byte data){
 87         //額外的加密操作...
 88         stream::Write(data);//寫文件流
 89         //額外的加密操作...
 90     }
 91 };
 92 
 93 
 94 
 95 class BufferedStream : public DecoratorStream{
 96     
 97     Stream* stream;//...
 98     
 99 public:
100     BufferedStream(Stream* stm):DecoratorStream(stm){
101         
102     }
103     //...
104 };
105 
106 
107 
108 
109 void Process(){
110 
111     //運行時裝配
112     FileStream* s1=new FileStream();
113     
114     CryptoStream* s2=new CryptoStream(s1);
115     
116     BufferedStream* s3=new BufferedStream(s1);
117     
118     BufferedStream* s4=new BufferedStream(s2);
119     
120     
121 
122 }
技術分享

Decorator模式使用動機：

在某些情況下我們可能會“過度地使用繼承來擴展對象的功能”，由於基礎為類型引入的靜態特指，使得這種擴展方式缺乏靈活性；並且隨著子類的增多（擴展功能的增多），各個子類的組合（擴展功能的組合）會導致各種子類的膨脹。

模式定義：

動態（組合）地給一個對象增加一些額外的指責。就增加功能而言，Decorator模式比聲場子類（繼承）更為靈活（消除重復代碼&減少子類個數）

類圖：

技術分享

要點總結：

1.通過采用組合並非繼承的手法，Decorator模式實現了在運行時動態擴展對象功能的能力，而且可以根據需要擴展多個功能。避免了使用繼承帶來的”靈活性差“和”多子類衍生問題“

2.Decorator類在接口上表現為is-a Component的繼承關系，即Decorator類繼承了Component類所具有的接口。但在實現上又表現為has-a Component的組合關系，即Decorator類又使用了另外一個Component類。

3.Decorator模式的目的並非解決”多字類衍生的多繼承“問題，Decorator模式應用的要點在於解決”主體類在多個方向上的擴展功能“（顯然file,network與加密，緩沖是兩種擴展方向） ——是為”裝飾“的含義。

參考文獻：

李建忠老師 《C++設計模式》網絡課程

《設計模式:可復用面向對象軟件的基礎》

c++ 設計模式6 （Decorator 裝飾模式）

相關推薦

c++ 設計模式6 （Decorator 裝飾模式）

ces 軟件組件 類繼承 通過 write height cte 中間 類型 4. “單一職責”類模式 在軟件組件的設計中，如果責任劃分的不清晰，使用繼承得到的結果往往是隨著需求的變化，子類急劇膨脹，同時充斥著重復代碼，這時候的關鍵是劃清責任。 典型模式代表： Decora

設計模式C++學習筆記之十三（Decorator裝飾模式）

com img c++ 進行 done 設計 out set 筆記 裝飾模式，動態地給一個對象添加一些額外的職責。就增加功能來說，Decorator模式相比生成子類更為靈活。 13.1.解釋 main()，老爸 ISchoolReport，成績單接口 CFourthGrad

c++ 設計模式7 （Bridge 橋模式）

設計模式 play 復制代碼 復用性 ict 只有一個 mage 單一職責原則 sea 4.2 Bridge 橋模式 動機： 由於某些類型的固有的實現邏輯，使得它們具有兩個變化的維度，乃至多個變化的維度。 代碼示例： 實現一個Messager，含有基本功能PlaySo

路一步步走>> 設計模式九：Decorator-裝飾

package com.test.DPs.JieGou.Decorator; /** * 結構型：Decorator-裝飾 裝飾：作用面為 物件 * * 用途:動態地給一個物件新增一些額外的職責。 * 理解：參考代理類 * 代理類：控制舊類物件的訪問和輸出結果 * 裝飾類：對

設計模式C++學習筆記之一（Strategy策略模式）

無意中，從網上下到一本電子書《24種設計模式介紹與6大設計原則》，很好奇這裡有24種設計模式，印象中GOF寫的《設計模式》（Design Patterns），好像只有23種吧。執行起來一看，還真挺吸引咱的，裡面提到的例子都很有趣。很感謝作者寫出這樣好的例子來，我的目的是把作者

設計模式のChainOfResponsibilityPattern（責任鏈模式）----行為模式

sys 參與 task gen ted 允許 nbsp write linq 一、產生背景 　　　　職責鏈模式是一種行為模式，為解除請求的發送者和接收者之間的耦合，而使多個對象都有機會處理這個請求。將這些對象連接成一條鏈，並沿著這條鏈傳遞該請求，直到有一個對象處理它。避免請

設計模式のMediatorPattern（中介者模式）----行為模式

短信 應該 console ons read 操作 namespace 原則 針對 一、產生背景 從生活中的例子可以看出，不論是QQ遊戲還是QQ群，它們都是充當一個中間平臺，QQ用戶可以登錄這個中間平臺與其他QQ用戶進行交流，如果沒有這些中間平臺，我們如果想與朋友進行聊天的

設計模式之結構型--裝飾模式

ret his 組合 子類 產生 margin per 調用 輸出 裝飾模式： 職責： 動態得為一個對象增加新的功能 裝飾模式是一種用於代替繼承的技術，無須通過繼承增加子類就 能擴展對象的新功能。使用對象的關聯關系代替繼承關系，更加靈活。 同時避免類型體系的快速膨脹

設計模式 十七 狀態模式State（物件行為型）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

設計模式 ( 十五 ) 觀察者模式Observer（物件行為型）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

常用設計模式總結（面試常問）

Singleton（單例模式） 一句話總結：一個類在Java虛擬機器中只有一個物件，並提供一個全域性訪問點。 生活中例子：太陽、月亮、國家主席等。 解決什麼問題：物件的唯一性，效能浪費太多。 專案裡面怎麼用：資料庫連線物件，屬性配置檔案的讀取物件。 模式結構：分為餓漢式和懶漢式（

設計模式教程（Design Patterns Tutorial）筆記之一 建立型模式（Creational Patterns）

目錄 · 概述 · Factory     · What is the Factory Design Pattern?     · 

設計模式之單例模式二（懶漢式double check）

上一篇文章中的懶漢式單例模式採用同步方法保證了執行緒安全，但是開銷很大，每次執行該方法都會檢查鎖。下面採用double check的方式進行改寫，下面這種實現看似可行，實則有缺陷，具體缺陷在後文分析： 注意上面第二幅圖中對lazyDoubleCheckSingl

設計模式之詳解——裝飾模式

裝飾模式 就是給一個物件增加一些新的功能，而且是動態的，要求裝飾物件和被裝飾物件實現同一個介面，裝飾物件持有被裝飾物件的例項。 用處： 需要擴充套件一個類的功能。 動態的為一個物件增加功能，而且還能動態撤銷。（繼承不能做到這一點，繼承的功能是靜態的，不能

Spring 5 設計模式 - 使用代理和裝飾模式的Spring AOP

Spring 5 設計模式 - 使用代理和裝飾模式的Spring AOP Spring中的代理模式 什麼是AOP AOP要解決的問題 程式碼糾纏 程式碼分散 解決 AOP的核心術語

《設計模式》學習筆記——裝飾模式

裝飾模式(Decorator Pattern)指的是在不必改變原類檔案和使用繼承的情況下，動態地擴充套件一個物件的功能.它是通過建立一個包裝物件，也就是裝飾來包裹真實的物件。 DecoratorPat

設計模式學習（橋接模式）

一.設計意圖：      將抽象部分與它的實現部分分離，將他們都可以獨立地變化。      手機有很多牌子且在不斷變換，但是App應用也會不斷增多。所以程式要讓抽象部分（手機）與實現部分（App）分類，獨自變換。我們就已這個例子來介紹橋接模式。 二.例子：      

設計模式總結（Java語言實現）

有人說，為什麼要學習設計模式，有些設計模式寫起來十分複雜，在平時程式設計時不會刻意去使用它。但是，設計模式是程式碼規範的一種體現，學號設計模式併合理應用，可以避免bug的出現，增強程式碼的魯棒性，便於後

資料庫模型設計連載之（單表模式 ）

原文地址：http://blog.csdn.net/liu7537/article/details/713966 （三）單表模式 單表模式，就是把相關子類的屬性統統集中在一個表裡，通過“類別”欄位來區分表內記錄所屬的子類以及該類的有效屬性。在實際案例當中，單表模式的應用

設計模式總結（不斷完善中...）

設計模式 簡單工廠模式 簡單工廠模式 oo思想: 某養豬大廠要求設計一個計算器，要求實現add、sub、mul、div,實際考察的是面向物件 的封裝、繼承和多型，那麼如何實現吶？封裝要做到業務層和檢視層分離，從控制檯接 收