设计模式---(简单工厂模式,工厂模式,抽象工程模式),单例模式,代理模式,装饰器

Posted sucfrperperseverance

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式---(简单工厂模式,工厂模式,抽象工程模式),单例模式,代理模式,装饰器相关的知识,希望对你有一定的参考价值。

简单工厂模式 

  简单工厂模式并不属于GoF的23种设计模式。 
  
  那么为什么我要用工厂模式呢?请看下面的一段程序。 

#include  <iostream> 
using  namespace  std; 
class  Fruit  { 
public: 
    Fruit(string  name)  { 
        this-­‐>name  =  name; 
        if  (name  ==  "apple")  { 
            //代表苹果 
        } 
        else  if  (name  ==  "banana")  { 
            //2  代表⾹香蕉 
        } 
        else  if  (name  ==  "pear")  { 
            //3  代表鸭梨 
        } 
    } 
    void  getName()  { 
        if  (name  ==  "apple")  { 
            cout  <<  "我是苹果"  <<  endl; 
        } 
        else  if  (name  ==  "banana")  { 
            cout  <<  "我是⾹香蕉"  <<  endl; 
        } 
        else  if  (name  ==  "pear")  { 
            cout  <<  "我是鸭梨"  <<  endl; 
        } 
    } 
private: 
    int  kind; 
    string  name; 
}; 
int  main(void) 
{ 
    Fruit  apple  =  Fruit("apple"); 
    Fruit  banana  =  Fruit("banana"); 
    Fruit  pear  =  Fruit("pear"); 
    apple.getName(); 
    banana.getName(); 
    pear.getName(); 
    return  0; 
}

不难看出,Fruit类是一个“巨大的”类,在该类的设计中存在如下几个问题: 
  (1)  在Fruit类中包含很多“if…else…”代码块,整个类的代码相当冗长,
代码越长,阅读难度、维护难度和测试难度也越大;而且大量条件语句的存在
还将影响系统的性能,程序在执行过程中需要做大量的条件判断。 
        (2)  Fruit类的职责过重,它负责初始化和显示所有的水果对象,将各种水
果对象的初始化代码和显示代码集中在一个类中实现,违反了“单一职责原
则”,不利于类的重用和维护;     
        (3)  当需要增加新类型的水果时,必须修改Fruit类的源代码,违反了“开
闭原则”。 

 

模式中的角色和职责
  工厂(Factory)角色:简单工厂模式的核心,它负责实现创建所有实例
的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。 
  抽象产品(AbstractProduct)角色:简单工厂模式所创建的所有对象的
父类,它负责描述所有实例所共有的公共接口。 
  具体产品(Concrete  Product)角色:简单工厂模式所创建的具体实例
对象。 

 

 

#include  <iostream> 
using  namespace  std; 
/* 
   定义一个水果抽象类,供具体水果实现,和工厂使用 
 */ 
class  Fruit  { 
public: 
    virtual  void  getName()  =  0; 
}; 
class  Apple  :public  Fruit  { 
public  : 
    virtual  void  getName()  { 
        cout  <<  "我是苹果"  <<  endl; 
    } 
}; 
class  Banana  :  public  Fruit  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "我是香蕉"  <<  endl; 
    } 
}; 
/* 
   现在添加一个鸭梨,那么只需要再创建一个鸭梨类 
   来实现抽象水果类即可。 
 */ 
?20
class  Pear  :public  Fruit  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "我是鸭梨"  <<  endl; 
    } 
}; 
class  Factory  { 
public  : 
    Fruit  *  createFruit(string  name)  { 
        if  (name  ==  "apple")  { 
            return  new  Apple; 
        } 
        else  if  (name  ==  "banana")  { 
            return  new  Banana; 
        } 
        /* 
           但是,当我们创建鸭梨的时候,Factory却变得越加庞大了 
           这样就不符合了开闭原则。 
         */ 
        else  if  (name  ==  "pear")  { 
            return  new  Pear; 
        } 
    } 
}; 
int  main(void) 
{ 
    Factory  *  factory  =  new  Factory; 
    Fruit  *  fruit  =  NULL; 
    /* 
       我们用工厂创建一个具体水果类,返回抽象类指针 
       那么这样就会发生多态。 
       此时抽象类指针指向了具体的子类,那么调用抽象方法 
       就会调用子类的实现方法。 
     */ 
    fruit  =  factory-­‐>createFruit("apple"); 
    fruit-­‐>getName(); 
    delete  fruit; 
    fruit  =  NULL; 
    fruit  =  factory-­‐>createFruit("banana"); 
    fruit-­‐>getName(); 
    delete  fruit; 
    fruit  =  NULL; 
    fruit  =  factory-­‐>createFruit("pear"); 
    fruit-­‐>getName(); 
    delete  fruit; 
    fruit  =  NULL; 
    delete  factory; 
    return  0; 
} 

优点:
1. 实现了对象创建和使用的分离。
2. 不需要记住具体类名,记住参数即可,减少使用者记忆量。
缺点:
1. 对工厂类职责过重,一旦不能工作,系统受到影响。
2. 增加系统中类的个数,复杂度和理解度增加。
3. 违反“开闭原则”,添加新产品需要修改工厂逻辑,工厂越来越复杂。

适用场景
       1.   工厂类负责创建的对象比较少,由于创建的对象较少,不会造成工厂
方法中的业务逻辑太过复杂。 
       2.  客户端只知道传入工厂类的参数,对于如何创建对象并不关心。 

 

 

 工厂方法模式 

工厂方法模式中的角色和职责 

 

 

抽象工厂(Abstract  Factory)角色:工厂方法模式的核心,任何工厂类
都必须实现这个接口。 
  工厂(Concrete  Factory)角色:具体工厂类是抽象工厂的一个实现,
负责实例化产品对象。 
  抽象产品(Abstract  Product)角色:工厂方法模式所创建的所有对象
的父类,它负责描述所有实例所共有的公共接口。   
具体产品(Concrete  Product)角色:工厂方法模式所创建的具体实例对象。

 

工厂方法模式的案例 

 

 

#include  <iostream> 
using  namespace  std; 
/* 
   创建一个水果抽象类,供具体的水果实现,和抽象工厂返回 
 */ 
class  Fruit  { 
public: 
    virtual  void  getName()  =  0; 
}; 
/* 
   创建一个工厂抽象类,供具体的水果工厂实现,并且返回抽象水果类 
 */ 
class  AbstractFactory  { 
public: 
    virtual  Fruit  *  createFruit()  =  0; 
}; 
class  Apple  :public  Fruit  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "我是苹果"  <<  endl; 
    } 
}; 
class  Banana  :  public  Fruit  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "我是⾹香蕉"  <<  endl; 
    } 
}; 
//实现了抽象工厂,并且返回⼀一个抽象水果指针 

class  AppleFactory  :public  AbstractFactory  { 
public: 
    virtual  Fruit  *  createFruit()  { 
        return  new  Apple; 
    } 
}; 
class  BananaFactory  :  public  AbstractFactory  { 
public: 
    virtual  Fruit  *createFruit()  { 
        return  new  Banana; 
    } 
}; 
/* 
   此时,如果要想添加一种 鸭梨 
   那么  不需要再去修改其中任何一个类, 
   而只需要实现一个鸭梨工厂,和一个鸭梨具体类 
 */ 
class  Pear  :  public  Fruit  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "我是鸭梨"  <<  endl; 
    } 
}; 
class  PearFactory  :  public  AbstractFactory  { 
public: 
    virtual  Fruit  *createFruit()  { 
        return  new  Pear; 
    } 
}; 
int  main(void) 
{ 
    /* 
       根据依赖倒转原则,  是针对接⼝口的编程, 
       那么,何为针对接口? 
       就是  我们只需要  使用  抽象工厂类的指针,和抽象水果类的指针, 
       通过多态的特性,就可以搞定完成具体类的业务。 
     */ 
    AbstractFactory  *abFactory  =  NULL; 
    Fruit  *fruit  =  NULL; 
    /* 
       抽象类指针,完成Apple  业务 
     */ 
    abFactory  =  new  AppleFactory; 
    fruit  =  abFactory-­‐>createFruit(); 
    fruit-­‐>getName(); 
    delete  abFactory; 
    delete  fruit; 
    /* 
?25
       抽象类指针,完成Banana  业务 
     */ 
    abFactory  =  new  BananaFactory; 
    fruit  =  abFactory-­‐>createFruit(); 
    fruit-­‐>getName(); 
    delete  abFactory; 
    delete  fruit; 
    /* 
       抽象类指针,完成Banana  业务 
     */ 
    abFactory  =  new  PearFactory; 
    fruit  =  abFactory-­‐>createFruit(); 
    fruit-­‐>getName(); 
    delete  abFactory; 
    delete  fruit; 
    return  0; 
}

优点:
1. 不需要记住具体类名,甚至连具体参数都不用记忆。
2. 实现了对象创建和使用的分离。
3. 系统的可扩展性也就变得非常好,无需修改接口和原类。
缺点:
1. 增加系统中类的个数,复杂度和理解度增加。
2. 增加了系统的抽象性和理解难度。


 适用场景
  1.  客户端不知道它所需要的对象的类。 
  2.  抽象工厂类通过其子类来指定创建哪个对象。

 

抽象工厂模式 
      工厂方法模式通过引入工厂等级结构,解决了简单工厂模式中工厂类职责
太重的问题,但由于工厂方法模式中的每个工厂只生产一类产品,可能会导致
系统中存在大量的工厂类,势必会增加系统的开销。此时,我们可以考虑将一
些相关的产品组成一个“产品族”,由同一个工厂来统一生产,这就是我们本
文将要学习的抽象工厂模式的基本思想。 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

抽象工厂(Abstract  Factory)角色:它声明了一组用于创建一族产品的
方法,每一个方法对应一种产品。 
  具体工厂(Concrete  Factory)角色:它实现了在抽象工厂中声明的创
建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品
都位于某个产品等级结构中。 
  抽象产品(Abstract  Product)角色:它为每种产品声明接口,在抽象
产品中声明了产品所具有的业务方法。
  具体产品(Concrete  Product)角色:它定义具体工厂生产的具体产品
对象,实现抽象产品接口中声明的业务方法。

 

抽象工厂模式案例

 

 

#include  <iostream> 
using  namespace  std; 
//苹果抽象类,供具体产地苹果实现 
class  AbstractApple   { 
public  : 
    virtual  void  getName()  =  0; 
}; 
//香蕉抽象类,供具体产地香蕉实现 
class  AbstractBanana   { 
public  : 
    virtual  void  getName()  =  0; 
}; 
class  ChinaApple  :  public  AbstractApple  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "中国苹果"  <<  endl; 
    } 
}; 
class  USAApple  :  public  AbstractApple  { 
public  : 
    virtual  void  getName()  { 
        cout  <<  "美国苹果"  <<  endl; 
    } 
}; 
class  ChinaBanana  :  public  AbstractBanana  { 
public  : 
    virtual  void  getName()  { 
        cout  <<  "中国⾹香蕉"  <<  endl; 
    } 
}; 
class  USABanana  :  public  AbstractBanana  { 
public: 
    virtual  void  getName()  { 
        cout  <<  "美国⾹香蕉"  <<  endl; 
    } 
}; 
//抽象的工厂类,供具体产品族的工厂实现 
class  AbstractFactory  { 
public: 
    virtual  AbstractApple  *  createApple()  =  0; 
    virtual  AbstractBanana  *  createBanana()  =  0; 
}; 
class  ChinaFactory  :  public  AbstractFactory  { 
public: 
?30
    virtual  AbstractApple  *  createApple()  { 
        return  new  ChinaApple; 
    } 
    virtual  AbstractBanana  *  createBanana()  { 
        return  new  ChinaBanana; 
    } 
}; 
class  USAFactory  :  public  AbstractFactory  { 
public: 
    virtual  AbstractApple  *  createApple()  { 
        return  new  USAApple; 
    } 
    virtual  AbstractBanana  *  createBanana()  { 
        return  new  USABanana; 
    } 
}; 
int  main(void) 
{ 
    //现在准备  要一个  中国的苹果,中国的香蕉 
    AbstractApple  *apple  =  NULL; 
    AbstractBanana  *banana  =  NULL; 
    AbstractFactory  *factory  =  NULL; 
    factory  =  new  ChinaFactory; 
    //中国的苹果 
    apple  =  factory-­‐>createApple(); 
    //中国的香蕉 
    banana  =  factory-­‐>createBanana(); 
    apple-­‐>getName(); 
    banana-­‐>getName(); 
    delete  apple; 
    delete  banana; 
    delete  factory; 
    return  0; 
}

1. 拥有工厂方法模式的优点
2. 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端
始终只使用同一个产品族中的对象。
3 增加新的产品族很方便,无须修改已有系统,符合“开闭原则”。
缺点:
1. 增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需
要修改抽象层代码,这显然会带来较大的不便,违背了“开闭原则”

适用场景
      (1)  系统中有多于一个的产品族。而每次只使用其中某一产品族。可以通过
配置文件等方式来使得用户可以动态改变产品族,也可以很方便地增加新的产
品族。 
      (2)  产品等级结构稳定。设计完成之后,不会向系统中增加新的产品等级结
构或者删除已有的产品等级结构。

 

 

  单例模式 
保证一个类、只有一个实例存在,同时提供能对该实例加以访问的全局


访问方法。
                (GoF给出单例模式的定义) 
三个要点:
  一是某个类只能有一个实例;
  二是它必须自行创建这个实例;
  三是它必须自行向整个系统提供这个实例。
 模式中的角色和职责

 


  Singleton(单例):在单例类的内部实现只生成一个实例,同时它提供
一个静态的getInstance()工厂方法,让客户可以访问它的唯一实例;为了防止
在外部对其实例化,将其构造函数设计为私有;在单例类内部定义了一个
Singleton类型的静态对象,作为外部共享的唯一实例。 
单例模式的使用步骤:
a)   构造函数私有化。
b)   提供一个全局的静态方法(全局访问点)来获取单例对象。
c)   在类中定义一个静态指针,指向本类的变量的静态变量指针  。

#include  <iostream> 
using  namespace  std; 
/*  
   懒汉模式 
*/ 
class  Singelton 
{ 
public: 
    /* 
       对外提供⼀一个全局静态方法 
     */ 
    static  Singelton  *  getInstance()  { 
        /* 
           懒汉式:  在调用全局静态方法,获取单例的时候, 
           再进行创建。懒汉式的单例创建在程序的执行中进行。 
         */ 
        if  (instance  ==  NULL)  { 
  //线程中加锁 instance
= new Singelton; }
//解锁 m_count
++; return instance; } int getCount() { return m_count; } private: /* 构造函数私有化 */ Singelton() { instance = NULL; m_count = 0; cout << "构造函数 singelton() 执行" << endl; } /* 在类中定义一个静态指针,指向本类的变量的静态变量指针 */ static Singelton *instance; static int m_count; }; /* 对静态变量的初始化,要放在类的外部, 即,放在全局位置上。 */ Singelton * Singelton::instance = NULL; int Singelton::m_count = 0; /* 饿汉模式 */ class Singelton2 { public: static Singelton2* getInstance() { m_count++; return instance; } int getCount() { return m_count; } private: Singelton2() { instance = NULL; m_count = 0; } static Singelton2 * instance; static int m_count; }; /* 饿汉式不是在全局静态方法中创建, 而是不管你创不创建实例,我在声明的 时候就创建出来, 饿汉式的单例,是在编译的时候就已经创建好了。 */ Singelton2 * Singelton2::instance = new Singelton2; int Singelton2::m_count = 0; int main(void) { Singelton * singer = Singelton::getInstance(); cout << singer-­‐>getCount() << endl; Singelton * singer2 = Singelton::getInstance(); cout << singer2-­‐>getCount() << endl; if (singer == singer2) { cout << "二者是同⼀一个实例" << endl; } else { cout << "二者不是同一个实例" << endl; } cout << "-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐ 以下 是 饿汉式 -­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐" << endl; Singelton2 * singer3 = Singelton2::getInstance(); cout << singer3-­‐>getCount() << endl; Singelton2 * singer4 = Singelton2::getInstance(); cout << singer4-­‐>getCount() << endl; if (singer3 == singer4) { cout << "⼆二者是同⼀一个实例" << endl; } else { cout << "⼆二者不是同⼀一个实例" << endl; } return 0; }

 


  



思考:
当单例模式中的懒汉模式遇见多线程,改怎么办?加锁
 单例模式的优缺点
优点:
(1) 单例模式提供了对唯一实例的受控访问。
(2) 节约系统资源。由于在系统内存中只存在一个对象。
缺点:
(1) 扩展略难。单例模式中没有抽象层。
(2) 单例类的职责过重。
3.4.4 适用场景
  (1)  系统只需要一个实例对象,如系统要求提供一个唯一的序列号生成器
或资源管理器,或者需要考虑资源消耗太大而只允许创建一个对象。 
        (2)  客户调用类的单个实例只允许使用一个公共访问点,除了该公共访问
点,不能通过其他途径访问该实例。

 

代理模式 
       Proxy模式又叫做代理模式,是构造型的设计模式之一,它可以为其他对象
提供一种代理(Proxy)以控制对这个对象的访问。
所谓代理,是指具有与代理元(被代理的对象)具有相同的接口的类,
客户端必须通过代理与被代理的目标类交互,而代理一般在交互的过程中(交
互前后),进行某些特别的处理。 


 模式中的角色和职责
       

 


  subject(抽象主题角色):真实主题与代理主题的共同接口。 
  RealSubject(真实主题角色):定义了代理角色所代表的真实对象。  
  Proxy(代理主题角色):含有对真实主题角色的引用,代理角色通常在
将客户端调用传递给真是主题对象之前或者之后执行某些操作,而不是单纯返
回真实的对象。 

4.1.2 代理模式的案例

 



#include  <iostream> 
#include  <string> 
using  namespace  std; 
class  Item  { 
public: 
    Item(string  kind,  bool  fact)  { 
        this-­‐>kind  =  kind; 
        this-­‐>fact  =  fact; 
    } 
    //物品类别 
    string  kind; 
    //是否真伪? 
    bool  fact; 
}; 
/* 
   抽象一种购物⽅方式,具有买功能。 
 */ 
class  Shopping  { 
public: 
    virtual  void  buy(Item  &  item)  =  0; 
}; 
/* 
   基于抽象类,实现一种具体的购物模式,去韩国购物 
 */ 
class  KoreaShopping  :  public  Shopping  { 

public: 
    virtual  void  buy(Item  &  item)  { 
        cout  <<  "去韩国进⾏行了购物,  买了"  <<  item.kind  <<  endl; 
    } 
}; 
/* 
   基于抽象类,实现⼀一种具体的购物模式,去美国购物 
 */ 
class  USAShopping  :  public  Shopping  { 
public: 
    virtual  void  buy(Item  &  item)  { 
        cout  <<  "去美国进⾏行了购物,  买了"  <<  item.kind  <<  endl; 
    } 
}; 
/* 
   基于抽象类,实现⼀一种具体的购物模式,去⾮非洲购物 
 */ 
class  AfrikaShopping  :  public  Shopping  { 
public: 
    virtual  void  buy(Item  &  item)  { 
        cout  <<  "去非洲进行了购物,  买了"  <<  item.kind  <<  endl; 
    } 
}; 
/* 
   有一个海外代购  代理,同样实现了购物模式, 
   而且增加了  办理护照  和  货物海关安检等  具体业务。 
 */ 
class  OverseasProxy  :  public  Shopping  { 
public: 
    OverseasProxy(Shopping  *  shopping)  { 
        this-­‐>shopMode  =  shopping; 
    } 
    ~OverseasProxy()  { 
        delete  this-­‐>shopMode; 
    } 
    //调⽤用  真实  购物模式  
    virtual  void  buy(Item  &  item)  { 
        if  (distinguish(item)  ==  true)  { 
            this-­‐>shopMode-­‐>buy(item); 
            check(item); 
        } 
        else  { 
            cout  <<  "发现伪货["<<item.kind<<"],不能购买"  <<  endl; 
        } 
    } 
    //辨别物品真伪 
    bool  distinguish(Item  &  item)  { 
        cout  <<  "对物品["  <<item.kind<<"]辨别真伪.  "  <<  endl; 
        return  item.fact; 

    } 
    //海关安检 
    void  check(Item  &item)  { 
        cout  <<  "通过海关安检,带回国内"  <<  endl; 
    } 
private: 
    Shopping  *  shopMode; 
}; 
int  main(void) 
{ 
    //  有⼏几种类型的物品 
    Item  t1("化妆品",  true); 
    Item  t2("CET4证书",  false); 
    Item  t3("addass运动鞋",  true); 
    Shopping  *shopping  =  NULL; 
    OverseasProxy  *  proxy  =  NULL; 
    //现在想要买这⼏几种物品 
    //1.  去韩国买  化妆品 
    proxy  =  new  OverseasProxy(new  KoreaShopping); 
    proxy-­‐>buy(t1); 
    delete  proxy; 
    //2  去美国买CET4  证书 
    proxy  =  new  OverseasProxy(new  USAShopping); 
    proxy-­‐>buy(t2); 
    delete  proxy; 
    //3  去⾮非洲买addass  
    proxy  =  new  OverseasProxy(new  AfrikaShopping); 
    proxy-­‐>buy(t3); 
    delete  proxy; 
    return  0; 
} 

  


 代理模式的种类
       (1)  远程代理(Remote  Proxy):为一个位于不同的地址空间的对象提供一
个本地的代理对象,这个不同的地址空间可以是在同一台主机中,也可是在另
一台主机中,远程代理又称为大使(Ambassador)。 

 


  
       (2)  虚拟代理(Virtual  Proxy):如果需要创建一个资源消耗较大的对象,先
创建一个消耗相对较小的对象来表示,真实对象只在需要时才会被真正创建。 
       (3)  保护代理(Protect  Proxy):控制对一个对象的访问,可以给不同的用
户提供不同级别的使用权限。 
       (4)  缓冲代理(Cache  Proxy):为某一个目标操作的结果提供临时的存储空
间,以便多个客户端可以共享这些结果。 
       (5)  智能引用代理(Smart  Reference  Proxy):当一个对象被引用时,提供
一些额外的操作,例如将对象被调用的次数记录下来等。 
 代理模式的优缺点
优点:
(1) 能够协调调用者和被调用者,在一定程度上降低了系统的耦合度。
(2) 客户端可以针对抽象主题角色进行编程,增加和更换代理类无须修改源
代码,符合开闭原则,系统具有较好的灵活性和可扩展性。
缺点:
(1) 代理实现较为复杂。
 适用场景
  为其他对象提供一种代理以控制对这个对象的访问。

 

 装饰模式 
  装饰模式(Decorator  Pattern):动态地给一个对象增加一些额外的职责,
就增加对象功能来说,装饰模式比生成子类实现更为灵活。装饰模式是一种对
象结构型模式。 
  
 装饰模式中的角色和职责


 


  Component(抽象构件):它是具体构件和抽象装饰类的共同父类,声
明了在具体构件中实现的业务方法,它的引入可以使客户端以一致的方式处理
未被装饰的对象以及装饰之后的对象,实现客户端的透明操作。 
  ConcreteComponent(具体构件):它是抽象构件类的子类,用于定
义具体的构件对象,实现了在抽象构件中声明的方法,装饰器可以给它增加额
外的职责(方法)。 
  Decorator(抽象装饰类):它也是抽象构件类的子类,用于给具体构件
增加职责,但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引
用,通过该引用可以调用装饰之前构件对象的方法,并通过其子类扩展该方法,
以达到装饰的目的。 

  ConcreteDecorator(具体装饰类):它是抽象装饰类的子类,负责向
构件添加新的职责。每一个具体装饰类都定义了一些新的行为,它可以调用在
抽象装饰类中定义的方法,并可以增加新的方法用以扩充对象的行为。 
4.2.2  装饰器案例 

 

 

#include  <iostream> 
#include  <string> 
using  namespace  std; 
2018.4.4 设计模式之简单工厂模式与抽象工厂模式详解

GOF三种工厂模式~

简单工厂模式

设计模式11:抽象工厂模式

设计模式之一(简单工厂模式)

抽象工厂模式