设计模式：装饰模式

1、装饰模式

1）定义

动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）。

2）动机（motivation）

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

> 如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响降为最低？

3）类图

Component：定义一个对象接口，可以给这些对象动态地添加职责。

ConcreteComponent：定义一个具体的对象，也可以给这个对象添加一些职责。

Decorator：装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的。

ConcreteDecoratorA：具体的装饰对象，起到给Component添加职责的功能。

4）代码实现

#include<iostream>
#include<memory>
using namespace std;

//流业务操作
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:
	char Read(int number) override {
		//读文件流
		std::cout << "* read file stream *" << std::endl;
		return 0;
	}
	void Seek(int position) override {
		//定位文件流
		std::cout << "* seek file stream *" << std::endl;
	}
	void Write(char data) override {
		//写文件流
		std::cout << "* write file stream *" << std::endl;
	}
};

class NetworkStream :public Stream {
public:
	char Read(int number) override {
		//读网络流
		std::cout << "* read network stream *" << std::endl;
		return 0;
	}
	void Seek(int position) override {
		//定位网络流
		std::cout << "* read network stream *" << std::endl;
	}
	void Write(char data) override {
		//写网络流
		std::cout << "* read network stream *" << std::endl;
	}
};

class MemoryStream :public Stream {
public:
	char Read(int number) override {
		//读内存流
		std::cout << "* read memory stream *" << std::endl;
		return 0;
	}
	void Seek(int position) override {
		//定位内存流
		std::cout << "* read memory stream *" << std::endl;
	}
	void Write(char data) override {
		//写内存流
		std::cout << "* read memory stream *" << std::endl;
	}
};

class DecoratorStream : public Stream { //继承-接口规范
public:
	DecoratorStream(Stream* _s):s(std::move(_s))
	{}
protected:
	//组合-复用实现
	Stream* s;// =new FileSream, new Networkstream, ...
};

//扩展操作
class CryptoStream : public DecoratorStream {
public:
	using DecoratorStream::DecoratorStream;

	char Read(int number) override {
		std::cout << "* Crypto Operation *" << std::endl;
		s->Read(number);//读流
		return 0;
	}
	void Seek(int position) override {
		std::cout << "* Crypto Operation *" << std::endl;
		s->Seek(position);//定位流
	}
	void Write(char data)override {
		std::cout << "* Crypto Operation *" << std::endl;
		s->Write(data);//写流
	}
};

class BufferedStream : public DecoratorStream {
public:
	using DecoratorStream::DecoratorStream;

	char Read(int number) override {
		std::cout << "* Buffer Operation *" << std::endl;
		s->Read(number);//读流
		return 0;
	}
	void Seek(int position) override {
		std::cout << "* Buffer Operation *" << std::endl;
		s->Seek(position);//定位流
	}
	void Write(char data)override {
		std::cout << "* Buffer Operation *" << std::endl;
		s->Write(data);//写流
	}
};

int main()
{
	std::cout << "----------------读文件流--------------" << std::endl;
	Stream* file_stream = new FileStream();
	file_stream->Read(0);
	std::cout << std::endl;

	std::cout << "----------------加密+读文件流--------------" << std::endl;
	Stream* cryto_stream = new CryptoStream(file_stream);
	cryto_stream->Read(0);
	std::cout << std::endl;

	std::cout << "----------------缓存+加密+读文件流--------------" << std::endl;
	Stream* buff_cryto_stream = new BufferedStream(cryto_stream);
	buff_cryto_stream->Read(0);
	std::cout << std::endl;

	delete buff_cryto_stream;
	delete cryto_stream;
	delete file_stream;

	system("pause");
	return 0;
}

运行结果如下：

 5）要点总结

> 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生的问题”。

> Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类使用了另外一个Component类。

> Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在与解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。