C++装饰器模式

UML图:

 #include <iostream>
 #include <string>
 #include <windows.h>
 using namespace std;
 //抽象类Cake
 class Cake
 {
 public:
     string m_name;
     //如果一个类中有纯虚函数
     //那么这个类无法被实例化
     //需要先继承再实例化
     virtual void show() = ;
 };
 class ConcreteCake:public Cake
 {
 public :
     ConcreteCake()
     {
         m_name = "原始蛋糕";
     }

     virtual void show()
     {
         cout << m_name.c_str() << endl;
     }

 };
 //抽象类Decorator
 class Decorator :public Cake
 {
 public :
     Cake * pCake;
     virtual void show() = ;
 };
 //具体奶油类
 class DecCream :public Decorator
 {
 public :
     DecCream(Cake * cake)
     {
         pCake = cake;
     }

     void show()
     {
         pCake->show();
         cout << "加奶油" << endl;
     }

 };
 //具体饼干类
 class DecBiscuits :public Decorator
 {
 public:
     DecBiscuits(Cake * cake)
     {
         pCake = cake;
     }

     void show()
     {
         pCake->show();
         cout << "加饼干" << endl;
     }

 };
 int main()
 {
     //原始蛋糕:先加奶油,再加饼干
     //ConcreteCake *  pOrinCake = new  ConcreteCake() ;
     //DecCream * pCream = new DecCream(pOrinCake);
     //DecBiscuits * pBiscuits = new DecBiscuits(pCream);
     //pBiscuits->show();

     //原始蛋糕:先加饼干,再加奶油
     ConcreteCake *  pOrinCake = new  ConcreteCake() ;
     DecBiscuits * pBiscuits = new DecBiscuits(pOrinCake);
     DecCream * pCream = new DecCream(pBiscuits);
     pCream->show();
     //可以看到上面创建了三个实例，单步调试可以观察到逐个调用实例show()方法的过程
     system("pause");
 }

装饰器模式的特点就是:

根据这个例子来说,重写show()的时候,会调用需要被装饰的类的原本的show(),在原来的show()的基础上再添加上自己的东西.

更通用地说,就是为方法增加新的功能,其实现机制是重写这个方法,并在重写的过程当中调用原本的方法并添加新的功能.

不改变原来方法的内容,只增不减.

优点:

可以根据自己的需要选择自己需要的部件(可以不按顺序地,无相互联系地)进行组合,以达到对象的方法随机应变拓展的效果,比继承来得更加灵活,而且更偏向于组合的思维模式.