设计模式之装饰模式

意图：动态地（组合）给一个对象添加一些额外的职责，就增加功能来说，Decorator模式相比生成子类更为灵活（消除重复代码，减少子类 数量）。

在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合)会导致更多子类的膨胀。

看下面的代码：

//代码在重复
class Stream
{
public:
	virtual char Read() = 0;
	virtual void Write() = 0;
	virtual ~Stream() {}
};
//主体类
class FileStream :public Stream
{
public:
	virtual char Read()
	{
		//...
	}
	virtual void Write()
	{
		//...
	}
};
//主体类
class NetworkStream :public Stream
{
public:
	virtual char Read()
	{
		//...
	}
	virtual void Write()
	{
		//...
	}
};

class CryptoFileStream :public FileStream
{
public:
	virtual char Read()
	{
		//额外的操作
		FileStream::Read();
	}
	virtual void Write()
	{
		//额外的操作
		FileStream::Write();
	}
};

class CryptoNetworkStream :public NetworkStream
{
public:
	virtual char Read()
	{
		//额外的操作
		NetworkStream::Read();
	}
	virtual void Write()
	{
		//额外的操作
		NetworkStream::Write();
	}
};
class CryptoButteredFileStream :public FileStream
{
public:
	virtual char Read()
	{
		//额外的加密操作
		//额外的缓冲操作
		FileStream::Read();
	}
	virtual void Write()
	{
		//额外的加密操作
		//额外的缓冲操作
		FileStream::Write();
	}
};

假如要扩展，那只能导致类越来越多，代码也会有很多重复。

修改如下：

//组合的方式
class Stream
{
public:
	virtual char Read() = 0;
	virtual void Write() = 0;
	virtual ~Stream() {}
};

class FileStream :public Stream
{
public:
	virtual char Read()
	{
		//...
	}
	virtual void Write()
	{
		//...
	}
};
class NetworkStream 
{
	Stream* stream;
public:
	virtual char Read()
	{
		//...
	}
	virtual void Write()
	{
		//...
	}
};
//既有基类成员，又继承基类
class CryptoStream:public DecoratorStream
{
//	Stream* stream;//=new FileStream();
public:
	CryptoStream(Stream* s) :DecoratorStream(s) {};
	virtual char Read()
	{
		//额外的操作
		stream->Read();
	}
	virtual void Write()
	{
		//额外的操作
		stream->Write();
	}
};

//装饰类
class DecoratorStream : public Stream
{
protected:
	Stream* stream;
public:
	DecoratorStream(Stream *s) :stream(s) {};
};
void Process()
{
	//通过装配来构造
	FileStream *fileStream = new FileStream();
	CryptoStream* cryptoFileStream = new CryptoStream(fileStream);
}

以组合的方式代替继承的方式的典型。