设计模式-1.1工厂模式

工厂模式分为三种：1）简单工厂模式；2）工厂方法模式；3）抽象工厂模式；

1.1.1 简单工厂模式

简单工厂模式：需要在工厂类中做判断，从而创造相应产品。一个工厂对应多个产品，需要一个工厂类和多个产品类，一个产品对应一个类，当新增产品时，需要新增产品类和修改工厂类，这样违背了软件设计原则，开放封闭原则：软件实体（类、模块、函数）可以扩展，但不可以修改。

 1 enum CTYPE {COREA, COREB};   

 2 class SingleCore  

 3 {  

 4 public:  

 5     virtual void Show() = 0;

 6 };  

 7 //单核A  

 8 class SingleCoreA: public SingleCore  

 9 {  

10 public:  

11     void Show() { cout<<"SingleCore A"<<endl; }  

12 };  

13 //单核B  

14 class SingleCoreB: public SingleCore  

15 {  

16 public:  

17     void Show() { cout<<"SingleCore B"<<endl; }  

18 };  

19 //唯一的工厂，可以生产两种型号的处理器核，在内部判断  

20 class Factory  

21 {  

22 public:   

23     SingleCore* CreateSingleCore(enum CTYPE ctype)  

24     {  

25         if(ctype == COREA) //工厂内部判断  

26             return new SingleCoreA(); //生产核A  

27         else if(ctype == COREB)  

28             return new SingleCoreB(); //生产核B  

29         else  

30             return NULL;  

31     }  

32 }; 

 

1.1.2 工厂方法模式

工厂方法模式：Factory Method，创建一个定义对象的接口，让子类去决定实例化哪个类，使一个类的实例化延迟到其子类。一个工厂专门负责一个产品。每增加一个新的产品，需要增加一个产品类和一个工厂类，这样不违背开放封闭原则，但当产品更新换代比较快时，都需要增加相应的工厂类，扩展性减弱。

 1 class SingleCore  

 2 {  

 3 public:  

 4     virtual void Show() = 0;

 5 };  

 6 //单核A  

 7 class SingleCoreA: public SingleCore  

 8 {  

 9 public:  

10     void Show() { cout<<"SingleCore A"<<endl; }  

11 };  

12 //单核B  

13 class SingleCoreB: public SingleCore  

14 {  

15 public:  

16     void Show() { cout<<"SingleCore B"<<endl; }  

17 };  

18 class Factory  

19 {  

20 public:  

21     virtual SingleCore* CreateSingleCore() = 0;

22 };  

23 //生产A核的工厂  

24 class FactoryA: public Factory  

25 {  

26 public:  

27     SingleCoreA* CreateSingleCore() { return new SingleCoreA; }  

28 };  

29 //生产B核的工厂  

30 class FactoryB: public Factory  

31 {  

32 public:  

33     SingleCoreB* CreateSingleCore() { return new SingleCoreB; }  

34 };

1.1.3 抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

 1 //单核  

 2 class SingleCore   

 3 {  

 4 public:  

 5     virtual void Show() = 0;

 6 };  

 7 class SingleCoreA: public SingleCore    

 8 {  

 9 public:  

10     void Show() { cout<<"Single Core A"<<endl; }  

11 };  

12 class SingleCoreB :public SingleCore  

13 {  

14 public:  

15     void Show() { cout<<"Single Core B"<<endl; }  

16 };  

17 //多核  

18 class MultiCore    

19 {  

20 public:  

21     virtual void Show() = 0;

22 };  

23 class MultiCoreA : public MultiCore    

24 {  

25 public:  

26     void Show() { cout<<"Multi Core A"<<endl; }  

27   

28 };  

29 class MultiCoreB : public MultiCore    

30 {  

31 public:  

32     void Show() { cout<<"Multi Core B"<<endl; }  

33 };  

34 //工厂  

35 class CoreFactory    

36 {  

37 public:  

38     virtual SingleCore* CreateSingleCore() = 0;

39     virtual MultiCore* CreateMultiCore() = 0;

40 };  

41 //工厂A，专门用来生产A型号的处理器  

42 class FactoryA :public CoreFactory  

43 {  

44 public:  

45     SingleCore* CreateSingleCore() { return new SingleCoreA(); }  

46     MultiCore* CreateMultiCore() { return new MultiCoreA(); }  

47 };  

48 //工厂B，专门用来生产B型号的处理器  

49 class FactoryB : public CoreFactory  

50 {  

51 public:  

52     SingleCore* CreateSingleCore() { return new SingleCoreB(); }  

53     MultiCore* CreateMultiCore() { return new MultiCoreB(); }  

54 }; 

参考出处：http://blog.csdn.net/wuzhekai1985/article/details/6660462