C++設計模式（六）裝飾模式

裝飾模式

“單一職責”模式：

• 在軟件組件地設計中，如果責任劃分地不清晰，使用繼承得到的結果往往是隨着需求地變化，子類極具膨脹，同時充斥着重複代碼，這時候地關鍵是劃清責任。
• 典型模式
  • Decorator
  • Bridge

動機（Motivation）

• 在某些情況下我們可能會“過度地使用繼承來擴展對象地功能”，由於繼承爲類型引入地靜態特質，使得這種擴展方式缺乏靈活性；並且隨着子類地增多（擴張功能地增多），各種子類地組合（擴張功能地組合）會導致更多子類地膨脹。
  • 靜態特質: FileStream::Read(number)
• 如何使“對象功能的擴展”能夠根據需要來動態地實現？同時避免“擴展功能地增多”帶來子類膨脹地問題？從而使得任何“功能擴展變化”所導致的影響將爲最低？

例子

比如在做流操作的類代碼編寫時，對不同類型有不同的讀寫方式，比如文件、網絡、內存。
然後在讀寫過程中，可能會遇到需要加密、緩存甚至既加密又緩存的情況。代碼可能會寫成下面的方式。

//業務操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;
	virtual ~Stream() {}
};

//主體類
class FileStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//寫文件流
	}

};

class NetworkStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀網絡流
	}
	virtual void Seek(int position) {
		//定位網絡流
	}
	virtual void Write(char data) {
		//寫網絡流
	}

};

class MemoryStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀內存流
	}
	virtual void Seek(int position) {
		//定位內存流
	}
	virtual void Write(char data) {
		//寫內存流
	}

};

//擴展操作
class CryptoFileStream : public FileStream{
public:
	virtual char Read(int number) {
		//額外的加密操作...
		FileStream::Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		FileStream::Seek(position);	//定位文件流
		//額外的加密操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		FileStream::Write(data);	//寫文件流
		//額外的加密操作...
	}
};

class CryptoNetworkStream : public NetworkStream{
public:
	virtual char Read(int number) {
		//額外的加密操作...
		NetworkStream::Read(number);	//讀網絡流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		NetworkStream::Seek(position);	//定位網絡流
		//額外的加密操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		NetworkStream::Write(data);	//寫網絡流
		//額外的加密操作...
	}
};

class CryptoMemoryStream : public MemorySteam {
public:
	virtual char Read(int number) {
		//額外的加密操作...
		MemoryStream::Read(number);	//讀內存流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		MemoryStream::Seek(position);	//定位內存流
		//額外的加密操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		MemoryStream::Write(data);	//寫內存流
		//額外的加密操作...
	}
};

class BufferFileStream : public FileStream {
	//...
};

class BufferNetworkStream : public NetworkStream {
	//...
};

class BufferMeomoryStream : public MemoryStream {
	//...
};

class CryptoBufferFileStream : public FileStream {
public:
	virtual char Read(int number) {
		//額外的加密操作...
		//額外的緩衝操作...
		FileStream::Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		//額外的緩衝操作...
		FileStream::Seek(position);	//定位文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		//額外的緩衝操作...
		FileStream::Write(data);	//寫文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
};

class CryptoBufferNetworkStream : public NetworkStream {
public:
	virtual char Read(int number) {
		//額外的加密操作...
		//額外的緩衝操作...
		NetworkStream::Read(number);	//讀網絡流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		//額外的緩衝操作...
		NetworkStream::Seek(position);	//定位網絡流
		//額外的加密操作...
		//額外的緩衝操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		//額外的緩衝操作...
		NetworkStream::Write(data);	//寫網絡流
		//額外的加密操作...
		//額外的緩衝操作...
	}
};

class CryptoBufferMemoryStream : public MemoryStream {
public:
	virtual char Read(int number) {
		//額外的加密操作...
		//額外的緩衝操作...
		MemoryStream::Read(number);	//讀內存流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		//額外的緩衝操作...
		MemoryStream::Seek(position);	//定位內存流
		//額外的加密操作...
		//額外的緩衝操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		//額外的緩衝操作...
		MemoryStream::Write(data);	//寫內存流
		//額外的加密操作...
		//額外的緩衝操作...
	}
};


void Process() {
	//編譯時裝配
	CryptoFileStream* fs1 = new CryptoFileStream();
	BufferFileStream* fs2 = new BufferFileStream();
	CryptoBufferFileStream* fs3 = new CryptoBufferFileStream();
}

改良思路

然後三種操作，其實stream相關的操作都是類似的。所以可以在類中用stream多態使用。這樣的話類就可以減少不少，在使用時賦值給類。但是類中函數還是虛函數，所以還是要遵守Stream的規範，繼承Stream基類。

//業務操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;
	virtual ~Stream() {}
};

//主體類
class FileStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//寫文件流
	}

};

class NetworkStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀網絡流
	}
	virtual void Seek(int position) {
		//定位網絡流
	}
	virtual void Write(char data) {
		//寫網絡流
	}

};

class MemoryStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀內存流
	}
	virtual void Seek(int position) {
		//定位內存流
	}
	virtual void Write(char data) {
		//寫內存流
	}

};

//擴展操作
class CryptoStream : public Stream {
	Stream* stream; // = new ...
public:
	CryptoStream(Stream* stm) :stream(stm) {

	}

	virtual char Read(int number) {
		//額外的加密操作...
		stream->Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		stream->Seek(position);	//定位文件流
		//額外的加密操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		stream->Write(data);	//寫文件流
		//額外的加密操作...
	}
};

class BufferedStream : public Stream {
	Stream* stream; //=new ...
	BufferedStream(Stream* stm) :stream(stm) {

	}
	//...
};

class CryptoBufferStream : public Stream {
	Stream* stream;	// = new ...
public:
	CryptoBufferStream(Stream* stm) :stream(stm) {

	}
	virtual char Read(int number) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Seek(position);	//定位文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Write(data);	//寫文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
};

void Process() {

	//運行時裝配
	FileStream* s1 = new FileStream();
	CryptoStream* s2 = new CryptoStream(s1);
	BufferedStream* s3 = new BufferedStream(s1);
	BufferedStream* s4 = new BufferedStream(s2);

}

更徹底的優化

如果類有很多類似的字段，應該往上提，提出來一個抽象類。Stream提到基類裏不合適，fileStream不需要。
類中相同的部分可以提取出來一個DecoratorStream類

//業務操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;
	virtual ~Stream() {}
};

//主體類
class FileStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//寫文件流
	}

};

class NetworkStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀網絡流
	}
	virtual void Seek(int position) {
		//定位網絡流
	}
	virtual void Write(char data) {
		//寫網絡流
	}

};

class MemoryStream : public Stream {
public:
	virtual char Read(int numer) {
		//讀內存流
	}
	virtual void Seek(int position) {
		//定位內存流
	}
	virtual void Write(char data) {
		//寫內存流
	}

};

//擴展操作
class DecoratorStream : public Stream {
protected:
	Stream* stream;	// = new ...
	DecoratorStream(Stream* stm) :stream(stm) {

	}
};

class CryptoStream : public DecoratorStream {
	Stream* stream; // = new ...
public:
	CryptoStream(Stream* stm) :stream(stm) {

	}

	virtual char Read(int number) {
		//額外的加密操作...
		stream->Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		stream->Seek(position);	//定位文件流
		//額外的加密操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		stream->Write(data);	//寫文件流
		//額外的加密操作...
	}
};

class BufferedStream : public DecoratorStream {
	Stream* stream; //=new ...
	BufferedStream(Stream* stm) :DecoratorStream(stm) {

	}
	//...
};

class CryptoBufferStream : public DecoratorStream {
	Stream* stream;	// = new ...
public:
	CryptoBufferStream(Stream* stm) :DecoratorStream(stm) {

	}
	virtual char Read(int number) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Read(number);	//讀文件流
	}
	virtual void Seek(int position) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Seek(position);	//定位文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
	virtual void Write(byte data) {
		//額外的加密操作...
		//額外的緩衝操作...
		stream->Write(data);	//寫文件流
		//額外的加密操作...
		//額外的緩衝操作...
	}
};

void Process() {

	//運行時裝配
	FileStream* s1 = new FileStream();
	CryptoStream* s2 = new CryptoStream(s1);
	BufferedStream* s3 = new BufferedStream(s1);
	BufferedStream* s4 = new BufferedStream(s2);

}

模式定義

動態（組合）地給一個對象增加一些額外地職責。就增加功能而言，Decorator模式比生成子類（繼承）更爲靈活（消除重複代碼&減少子類個數）。 ——《設計模式》GoF

結構（Structure）

Component類型相當於Stream類型，Decorator相當於DecoratorStream。ConcreteComponent時FileStream、NetwoStream、MemoryStream。ConcreteDecoratorA相當於CyrptoStream和BufferedStream。

要點總結

• 通過採用組合而非繼承地手法，Decorator模式實現了在運行時動態擴展對象功能的能力，而且可以更具需要擴展多個功能。避免了使用繼承帶來的“靈活性差”和“多子類衍生問題”。
• Decorator類在接口上表現爲is-a Component的繼承關係，即Decorator類繼承了Component類所具有的接口。但在實現上有表現爲has-a Component的組合關係，即Decorator類又使用了另外一個Component類。
• Decorator模式的目的並非解決“多子類衍生的多繼承”問題，Decorator模式應用的要點在於解決“主題類在多個方向上的擴展功能”——是爲“裝飾”的含義。