动机

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

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

    模式定义

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

    未使用该设计模式

    ```cpp //业务操作 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 number) { //读文件流 } virtual void Seek(int position) { //定位文件流 } virtual void Write(char data) { //写文件流 } };

class NetworkStream : public Stream { public: virtual char Read(int number) { //读文件流 } virtual void Seek(int position) { //定位文件流 } virtual void Write(char data) { //写文件流 } };

class MemoryStream : public Stream { public: virtual char Read(int number) { //读文件流 } virtual void Seek(int position) { //定位文件流 } virtual void Write(char data) { //写文件流 } };

//扩展操作 class CrytoFileStream : public FileStream { public: virtual char Read(int number) { //额外的加密操作 FileStream::Read(number); //读文件流 //额外的加密操作 } virtual void Seek(int position) { //额外的加密操作 FileStream::Seek(position); //定位文件流 //额外的加密操作 } virtual void Write(char data) { //额外的加密操作 FileStream::Write(data); //写文件流 //额外的加密操作 } };

//扩展操作 class CrytoNetworkStream : public NetworkStream { public: virtual char Read(int number) { //额外的加密操作 //(59,80,101行代码相同，导致代码冗余） NetworkStream::Read(number); //读文件流 //额外的加密操作 } virtual void Seek(int position) { //额外的加密操作 NetworkStream::Seek(position); //定位文件流 //额外的加密操作 } virtual void Write(char data) { //额外的加密操作 NetworkStream::Write(data); //写文件流 //额外的加密操作 } };

//扩展操作 class CrytoMemoryStream : public MemoryStream { public: virtual char Read(int number) { //额外的加密操作 MemoryStream::Read(number); //读文件流 //额外的加密操作 } virtual void Seek(int position) { //额外的加密操作 MemoryStream::Seek(position); //定位文件流 //额外的加密操作 } virtual void Write(char data) { //额外的加密操作 MemoryStream::Write(data); //写文件流 //额外的加密操作 } };

class BufferedFileStream : public FileStream { //… }; class BufferedNetworkStream : public NetworkStream { //… }; class BufferedMemoryStream : public MemoryStream { //… };

class CrytoBufferedFileStream : public FileStream { public: virtual char Read(int number) { //额外的加密操作 //额外的缓存操作 FileStream::Read(number); //读文件流 //额外的加密操作 //额外的缓存操作 } virtual void Seek(int position) { //额外的加密操作 //额外的缓存操作 FileStream::Seek(position); //定位文件流 //额外的加密操作 //额外的缓存操作 } virtual void Write(char data) { //额外的加密操作 //额外的缓存操作 FileStream::Write(data); //写文件流 //额外的加密操作 //额外的缓存操作 } };

void Process() { // 编译时装配 CrytoFileStream* fs1 = new CrytoFileStream();

  1. BufferedFileStream* fs2 = new BufferedFileStream();
  3. CrytoBufferedFileStream *fs3 = new CrytoBufferedFileStream();

}

  1. <a name="Q0rBY"></a>
  2. #### 存在的问题
  3. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/2719428/1622965793834-212468cb-1d79-4bd8-b8be-a9a363eb4af0.png#align=left&display=inline&height=404&margin=%5Bobject%20Object%5D&name=image.png&originHeight=539&originWidth=1210&size=346774&status=done&style=none&width=908)
  4. <a name="l2yyB"></a>
  5. ### 实现2
  6. ```cpp
  7. //业务操作
  8. class Stream{
  9. public:
  10.     virtual char Read(int number) = 0;
  11.     virtual void Seek(int position) = 0;
  12.     virtual void Write(char data) = 0;
  14.     virtual ~Stream() {}
  15. };
  17. //主体类
  18. class FileStream : public Stream
  19. {
  20. public:
  21.     virtual char Read(int number) {
  22.         //读文件流
  23.     }
  24.     virtual void Seek(int position) {
  25.         //定位文件流
  26.     }
  27.     virtual void Write(char data) {
  28.         //写文件流
  29.     }
  30. };
  32. class NetworkStream : public Stream
  33. {
  34. public:
  35.     virtual char Read(int number) {
  36.         //读文件流
  37.     }
  38.     virtual void Seek(int position) {
  39.         //定位文件流
  40.     }
  41.     virtual void Write(char data) {
  42.         //写文件流
  43.     }
  44. };
  46. class MemoryStream : public Stream
  47. {
  48. public:
  49.     virtual char Read(int number) {
  50.         //读文件流
  51.     }
  52.     virtual void Seek(int position) {
  53.         //定位文件流
  54.     }
  55.     virtual void Write(char data) {
  56.         //写文件流
  57.     }
  58. };
  60. //扩展操作
  61. /*合并*/
  62. //class CrytoFileStream
  63. //{
  64. //    Stream* stream;        //= new FileStream();
  65. //public:
  66. //    virtual char Read(int number) {
  67. //        //额外的加密操作                //(59,80,101行代码相同，导致代码冗余）
  68. //        stream->Read(number);    //读文件流
  69. //        //额外的加密操作
  70. //    }
  71. //    virtual void Seek(int position) {
  72. //        //额外的加密操作
  73. //        stream->Seek(position);    //定位文件流
  74. //        //额外的加密操作
  75. //    }
  76. //    virtual void Write(char data) {
  77. //        //额外的加密操作
  78. //        stream->Write(data);    //写文件流
  79. //        //额外的加密操作
  80. //    }
  81. //};
  82. //
  83. ////扩展操作
  84. //class CrytoNetworkStream
  85. //{
  86. //    Stream* stream;        //= New NetworkStream();
  87. //public:
  88. //    virtual char Read(int number) {
  89. //        //额外的加密操作
  90. //        stream->Read(number);    //读文件流
  91. //        //额外的加密操作
  92. //    }
  93. //    virtual void Seek(int position) {
  94. //        //额外的加密操作
  95. //        stream->Seek(position);    //定位文件流
  96. //        //额外的加密操作
  97. //    }
  98. //    virtual void Write(char data) {
  99. //        //额外的加密操作
  100. //        stream->Write(data);    //写文件流
  101. //        //额外的加密操作
  102. //    }
  103. //};
  104. //
  105. ////扩展操作
  106. //class CrytoMemoryStream
  107. //{
  108. //    Stream* stream;        //= new MemoryStream();
  109. //public:
  110. //    virtual char Read(int number) {
  111. //        //额外的加密操作
  112. //        stream->Read(number);    //读文件流
  113. //        //额外的加密操作
  114. //    }
  115. //    virtual void Seek(int position) {
  116. //        //额外的加密操作
  117. //        stream->Seek(position);    //定位文件流
  118. //        //额外的加密操作
  119. //    }
  120. //    virtual void Write(char data) {
  121. //        //额外的加密操作
  122. //        stream->Write(data);    //写文件流
  123. //        //额外的加密操作
  124. //    }
  125. //};
  126. class CryptoStream : public Stream
  127. {
  128.     Stream* stream;        //...
  129. public:
  130.     CryptoStream(Stream* stm) :stream(stm)
  131.     {
  133.     }
  134.     virtual char Read(int number) {
  135.         //额外的加密操作            
  136.         stream->Read(number);    //读文件流
  137.         //额外的加密操作
  138.     }
  139.     virtual void Seek(int position) {
  140.         //额外的加密操作
  141.         stream->Seek(position);    //定位文件流
  142.         //额外的加密操作
  143.     }
  144.     virtual void Write(char data) {
  145.         //额外的加密操作
  146.         stream->Write(data);    //写文件流
  147.         //额外的加密操作
  148.     }
  149. };
  150. /*合并*/
  151. //class BufferedFileStream : public FileStream {
  152. //    //...
  153. //};
  154. //class BufferedNetworkStream : public NetworkStream {
  155. //    //...
  156. //};
  157. //class BufferedMemoryStream : public MemoryStream {
  158. //    //...
  159. //};
  160. class BufferedStream : public Stream {
  161.     Stream* stream;
  162. public:
  163.     BufferedStream(Stream* stm) :stream(stm)
  164.     {
  166.     }
  167.     virtual char Read(int number) {
  168.         //额外的传冲操作            
  169.         stream->Read(number);    //读文件流
  170.         //额外的传冲操作
  171.     }
  172.     virtual void Seek(int position) {
  173.         //额外的传冲操作
  174.         stream->Seek(position);    //定位文件流
  175.         //额外的传冲操作
  176.     }
  177.     virtual void Write(char data) {
  178.         //额外的传冲操作
  179.         stream->Write(data);    //写文件流
  180.         //额外的传冲操作
  181.     }
  182. };
  184. void Process() {
  185.     // 运行时装配
  186.     FileStream* s1 = new FileStream();
  187.     CryptoStream* s2 = new CryptoStream(s1);
  188.     BufferedStream* s3 = new BufferedStream(s1);
  189.     BufferedStream* s4 = new BufferedStream(s2);
  190. }

实现3

  1. //业务操作
  2. class Stream{
  3. public:
  4.     virtual char Read(int number) = 0;
  5.     virtual void Seek(int position) = 0;
  6.     virtual void Write(char data) = 0;
  8.     virtual ~Stream() {}
  9. };
  11. //主体类
  12. class FileStream : public Stream
  13. {
  14. public:
  15.     virtual char Read(int number) {
  16.         //读文件流
  17.     }
  18.     virtual void Seek(int position) {
  19.         //定位文件流
  20.     }
  21.     virtual void Write(char data) {
  22.         //写文件流
  23.     }
  24. };
  26. class NetworkStream : public Stream
  27. {
  28. public:
  29.     virtual char Read(int number) {
  30.         //读文件流
  31.     }
  32.     virtual void Seek(int position) {
  33.         //定位文件流
  34.     }
  35.     virtual void Write(char data) {
  36.         //写文件流
  37.     }
  38. };
  40. class MemoryStream : public Stream
  41. {
  42. public:
  43.     virtual char Read(int number) {
  44.         //读文件流
  45.     }
  46.     virtual void Seek(int position) {
  47.         //定位文件流
  48.     }
  49.     virtual void Write(char data) {
  50.         //写文件流
  51.     }
  52. };
  54. class DecoratorStream : public Stream
  55. {
  56. protected:
  57.     Stream* stream;        //...
  58.     DecoratorStream(Stream* stm) : stream(stm)
  59.     {
  61.     }
  62. };
  64. class CryptoStream : public DecoratorStream
  65. {
  66. public:
  67.     CryptoStream(Stream* stm) : DecoratorStream(stm)
  68.     {
  70.     }
  71.     virtual char Read(int number) {
  72.         //额外的加密操作            
  73.         stream->Read(number);    //读文件流
  74.         //额外的加密操作
  75.     }
  76.     virtual void Seek(int position) {
  77.         //额外的加密操作
  78.         stream->Seek(position);    //定位文件流
  79.         //额外的加密操作
  80.     }
  81.     virtual void Write(char data) {
  82.         //额外的加密操作
  83.         stream->Write(data);    //写文件流
  84.         //额外的加密操作
  85.     }
  86. };
  88. class BufferedStream : public DecoratorStream {
  89. public:
  90.     BufferedStream(Stream* stm) : DecoratorStream(stm)
  91.     {
  93.     }
  94.     virtual char Read(int number) {
  95.         //额外的传冲操作            
  96.         stream->Read(number);    //读文件流
  97.         //额外的传冲操作
  98.     }
  99.     virtual void Seek(int position) {
  100.         //额外的传冲操作
  101.         stream->Seek(position);    //定位文件流
  102.         //额外的传冲操作
  103.     }
  104.     virtual void Write(char data) {
  105.         //额外的传冲操作
  106.         stream->Write(data);    //写文件流
  107.         //额外的传冲操作
  108.     }
  109. };
  111. void Process() {
  112.     // 运行时装配
  113.     FileStream* s1 = new FileStream();
  114.     CryptoStream* s2 = new CryptoStream(s1);
  115.     BufferedStream* s3 = new BufferedStream(s1);
  116.     BufferedStream* s4 = new BufferedStream(s2);
  117. }

image.png
image.png