定义

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。装饰模式属于结构型模式，它是作为现有的类的一个包装。

案例

我们有一系列的流式读写操作，如文件流、网络流、内存流等等。

class Stream { public: 	virtual ~Stream() {} 	virtual char read(int num) = 0; 	virtual void write(char data) = 0; };  class FileStream : public Stream { public: 	virtual ~FileStream() {} 	virtual char read(int num)  	{ 		// FileStream read operation 	} 	 	virtual void write(char data) 	{ 		// FileStream write operation 	} };  class NetStream : public Stream { public: 	virtual ~NetStream () {} 	virtual char read(int num)  	{ 		// NetStream read operation 	} 	 	virtual void write(char data) 	{ 		// NetStream write operation 	} };  class MemoryStream : public Stream { public: 	virtual ~MemoryStream () {} 	virtual char read(int num)  	{ 		// MemoryStream read operation 	} 	 	virtual void write(char data) 	{ 		// MemoryStream write operation 	} }; 

上述各子类对应不同的流操作，我们可以按照需求直接使用这些子类生成对象：

void main() { 	Stream *s = new FileStream; 	s->write('x'); 	delete s;  } 

如果我们还需要别的功能，比如对数据流进行加密、缓存等操作，我们可能会写出如下代码：

class CryptoFileStream : public FileStream { public: 	char read(int num) { 		char c = FileStream::read(num); 		// 执行一些加密操作 		return c; 	} 	 	void write(char data) { 		// 执行一些加密操作 		FileStream::write(data); 	} };  class CryptoNetStream : public NetStream{ public: 	char read(int num) { 		char c = NetStream::read(num); 		// 执行一些加密操作 		return c; 	} 	 	void write(char data) { 		// 执行一些加密操作 		NetStream::write(data); 	} };  class CryptoMemoryStream  : public MemoryStream { public: 	char read(int num) { 		char c = MemoryStream::read(num); 		// 执行一些加密操作 		return c; 	} 	 	void write(char data) { 		// 执行一些加密操作 		MemoryStream::write(data); 	} }; 

事实上，上述这些加密过程是完全一样的，但是却为此创建了三个子类。有没有办法减少子类的创建呢？请看如下方式：

// 装饰基类 class DecoratorStream { protected: 	Stream* _stream; 	DecoratorStream(Stream* stream) : _stream(stream) {} };  // 带加密功能的装饰器 class CryptoStream : public DecoratorStream { public: 	CryptoStream(Stream* stream) : DecoratorStream(stream) {} 	 	char read(int num) { 		char c = _stream->read(num); 		// 执行一些加密操作 		return c; 	} 	 	void write(char data) { 		// 执行一些加密操作 		_stream->write(data); 	} }; 

可以看到，在使用装饰模式后，子类的个数减少到了一个（不包括装饰器基类）。其原理就是利用多态特性，将read、write操作的具体行为延迟到了运行期。而在这之前，我们是在编译期就确定了。使用方式如下：

void main() { 	Stream *s1 = new FileStream; 	s1->write('x'); 	CryptoStream* cs1 = new CryptoStream(s1); // 此时就拥有了具有加密功能的文件流对象 	char c = cs1->read(0);  	Stream *s2 = new NetStream; 	CryptoStream* cs2 = new CryptoStream(s2); // 此时就拥有了具有加密功能的网络流对象 	cs2->write('y'); 	delete cs2; 	delete s2; 	delete cs1; 	delete s1; } 

事实上，在不使用装饰模式的时候，我们的主体功能（文件流、网络流、内存流等）在扩展其他功能的时候（加密、解密、缓存等），其扩展的方式如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LBqEGAbH-1721228204488)(/zb_users/upload/2024/csdn/387432e0ac9744f3a01d670a082761b5.png)]
这里的1+n+n*m!/2代表的是类的个数，n代表主体功能，m代表扩展功能。可见在只使用继承的方式时，衍生出大量的子类。而使用装饰模式之后，其扩展方式如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OUhSfMFS-1721228204491)(/zb_users/upload/2024/csdn/38b721e2ecd84abcb9498028846a723b.png)]
其中，扩展功能（装饰类）直接继承Stream类，因此扩展功能和主体功能的扩展是两个不同的方向，新增扩展功能时，只需要添加一个子类即可。

类图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O0m0n9qQ-1721228204492)(/zb_users/upload/2024/csdn/8158715851b248a3a323da68b1b53fd7.png)]
对比类图，Componet就是Stream基类，ConcretComponet是一些基础的流操作类（文件流、网络流等），Decorator就是装饰器基类，ConcretDecorator就是具体功能的装饰类（如加密、解密、缓存等）。

总结

• 通过使用组合而非继承的方式，实现了运行时动态扩展对象功能的能力，并且根据需要可以扩展多个功能，避免继承带来的灵活性差和多子类衍生的问题。
• 装饰类在接口上表现为is-a Component的继承关系，继承了Component的所有接口。但是在实现上，又表现为has-a的组合关系，即装饰类又使用了另一个Componet类。
• 装饰模式并非单纯为了解决多子类衍生的问题，而是解决主体在多个方向上扩展功能的问题。