设计模式之装饰器模式

最近看到《设计之禅》的装饰器模式，特用C++实现了一遍，发现有些有意思的东西需要探究一下。
UML类图：

 

 

一. C++实现

#include <stdio.h>


/// Base
class Component
{
public:
  virtual ~Component(){}
  virtual int operate() = 0;
};


/// ConcreteComponent
class ConcreteComponent: public Component
{
public:
  ConcreteComponent()
  {
    
  }
  
  virtual ~ConcreteComponent()
  {
    printf("ConcreteComponent Destroy %#04x\n", this);
  }
  
  int operate()
  {
    printf("ConcreteComponent operate\n");
    return 0;
  }
};


/// Decorator
class Decorator: public Component
{
public:
  virtual ~Decorator()
  {
    printf("Decorator destroy:%#04x base:%#04x\n", this, m_component);
    
    delete m_component;
    m_component = NULL;
  }
  
protected:
  Component* m_component;
};


/// ConcreteDecoratorA
class ConcreteDecoratorA: public Decorator
{
public:
  explicit ConcreteDecoratorA(Component *ins)
  {
    m_component = ins;
  }

  ~ConcreteDecoratorA()
  {
    printf("ConcreteDecoratorA destroy:%#04x\n", this);
  }
  
  int operate()
  {
    int ret = m_component->operate();
    
    printf("ConcreteDecoratorA operate\n");
    return ret;
  }
};


/// ConcreteDecoratorB
class ConcreteDecoratorB: public Decorator
{
public:
  explicit ConcreteDecoratorB(Component *ins)
  {
    m_component = ins;
  }
  
  ~ConcreteDecoratorB()
  {
    printf("ConcreteDecoratorB destroy:%#04x\n", this);
  }
  
  int operate() 
  {
    int ret = m_component->operate();
    
    printf("ConcreteDecoratorB operate\n");
    return ret;
  }
};


// 检测指针是否释放
Component *p = NULL, *q = NULL, *h = NULL;

/**
 * main
 */
int main(int argc, char **argv)
{
  Component *component = new ConcreteComponent();   p = component;
  component = new ConcreteDecoratorA(component);    q = component;
  component = new ConcreteDecoratorB(component);    h = component;
  component->operate();
  
  printf("Concrete:%#04x Concrete1:%#04x Concrete2:%#04x\n\n", p, q, h);
  
  // 内存是否泄露？
  delete component;
  component = NULL;
  
  return 0;
}

 

装饰器模式提供比继承更有弹性的扩展方案，缺点产生了大量包装类，业务逻辑比较复杂。

上图实现是调用了三次new，却只delete一次，是否会发生内存泄露？

 

先看结果：

ConcreteComponent operate
ConcreteDecoratorA operate
ConcreteDecoratorB operate
Concrete:0x21d9010 Concrete1:0x21d9030 Concrete2:0x21d9050

ConcreteDecoratorB destroy:0x21d9050
Decorator destroy:0x21d9050 base:0x21d9030
ConcreteDecoratorA destroy:0x21d9030
Decorator destroy:0x21d9030 base:0x21d9010
ConcreteComponent Destroy 0x21d9010

 

分析：在析构ConcreteDecoratorB后，会再析构父类Decorator，但此次的Decorator已被构造函数替换成ConcreteDecoratorA，则析构ConcreteDecoratorA，同理再析构ConcreteComponent。通过Componenet成员变量达到析构了所有堆变量，实在是高！

 

 二. java IO

Java IO提供很多实用的工具类，各种read(), readLine() 调用，典型的装饰器模式。

FileInputStream fis = new FileInputStream("~/test.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
bis.read(b, off, len);

 

源码跟踪：

BufferedInputStream::read(b, off, len);

getInIfOpen().read(b, off, len);

InputStream::read(b, off, len);

 

 

BufferedInputStream利用缓冲输入改善行为，底层调用FileInputStream的read()，而FileInputStream调用InputStream的read()。