装饰模式原理与C++实现

定义

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

案例

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

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;
}

事实上，在不使用装饰模式的时候，我们的主体功能（文件流、网络流、内存流等）在扩展其他功能的时候（加密、解密、缓存等），其扩展的方式如下：

这里的1+n+n*m!/2代表的是类的个数，n代表主体功能，m代表扩展功能。可见在只使用继承的方式时，衍生出大量的子类。而使用装饰模式之后，其扩展方式如下：

其中，扩展功能（装饰类）直接继承Stream类，因此扩展功能和主体功能的扩展是两个不同的方向，新增扩展功能时，只需要添加一个子类即可。

类图

对比类图，Componet就是Stream基类，ConcretComponet是一些基础的流操作类（文件流、网络流等），Decorator就是装饰器基类，ConcretDecorator就是具体功能的装饰类（如加密、解密、缓存等）。

总结

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