设计模式之工厂模式、抽象工厂模式、单例模式(C++代码)

设计模式的重要性就不用多说了。各种设计模式在实际项目中用的是比比皆是。

一：简单工厂模式和工厂模式

懂得一点UML，一看这幅类图，就知道工厂模式是用来干嘛的，说白了，就是提供一个抽象的基类接口，使得用户不用记住具体的要成成的新的类的名字。

下面 看一段代码：

[cpp]  view plain copy

1. #include<iostream>  
2. #include<string>  
3. #include<vector>  
4. using namespace std;  
5.   
6. class Product  
7. {  
8. public:  
9.     Product(){}  
10.     ~Product(){};  
11.   
12. };  
13.   
14. class ProductA:public Product  
15. {  
16. public:  
17.     ProductA(){cout<<"ProductA"<<endl;}  
18.     ~ProductA(){}  
19. };  
20.   
21. class Factory  
22. {  
23. public:  
24.     Factory(){}  
25.     ~Factory(){}  
26.     ProductA* createProductA()  
27.     {  
28.         return new ProductA();  
29.     }  
30. };  
31.   
32. int main()  
33. {  
34.     Factory f;//简单工厂模式  
35.     ProductA* pa=f.createProductA();  
36.     system("pause");  
37.     return 0;  
38. }  

这里只列举了一个产品，可以自行扩展多个产品，比如产品都有：香蕉、苹果、橘子等等。指需要通知一声工厂，工厂就会调用相应的 生产香蕉、生产苹果、生产橘子等函数、而客户不需要知道生产这些水果的具体过程。坐着等吃就行。

工厂模式的类图如下，具体代码省。。

二 ：抽象工厂模式

上面 所讲的工厂模式还不够抽象，因为只有产品抽象了，工厂并未抽象，上面所讲的是一个工厂生产了所有需要的产品，但是，你想想，假设HTC厂家生产ＨＴＣ手机、ＨＴＣ电池、诺基亚手机。。。你觉得很奇怪吗，　这个时候就需要抽象工厂模式来解决了，ＨＴＣ应该生产ＨＴＣ旗下的产品、苹果生产苹果系列的产品，这样管理起来也方便。

看看代码例子：

[cpp]  view plain copy

1. #include<iostream>  
2. #include<string>  
3. #include<vector>  
4. using namespace std;  
5.   
6. class AbstractPruduct  
7. {  
8. public:  
9.     AbstractPruduct(){}  
10.     ~AbstractPruduct(){}  
11.     virtual void print()=0;  
12.   
13. };  
14.   
15. class ProductA:public AbstractPruduct  
16. {  
17. public:  
18.     ProductA(){cout<<"ProductA"<<endl;}  
19.     ~ProductA(){}  
20.     void print()  
21.     {  
22.         cout<<"I'm ProductA"<<endl;  
23.     }  
24. };  
25.   
26. class ProductB:public AbstractPruduct  
27. {  
28. public:  
29.     ProductB(){cout<<"ProductB"<<endl;}  
30.     ~ProductB(){}  
31.     void print()  
32.     {  
33.         cout<<"I'm ProductB"<<endl;  
34.     }  
35. };  
36.   
37. class AbstractFactory  
38. {  
39. public:  
40.     AbstractFactory(){}  
41.     ~AbstractFactory(){}  
42.   
43.   
44. };  
45.   
46. class   FactoryA:public AbstractFactory  
47. {  
48. public:  
49.     FactoryA(){cout<<"FactoryA"<<endl;}  
50.     ~FactoryA(){}  
51.     ProductA* createProduct()  
52.     {  
53.         return new ProductA();  
54.     }  
55. };  
56.   
57. class FactoryB:public AbstractFactory  
58. {  
59. public:  
60.     FactoryB(){cout<<"FactoryB"<<endl;}  
61.     ~FactoryB(){}  
62.     ProductB* createProduct()  
63.     {  
64.         return new ProductB();  
65.     }  
66. };  
67.   
68.   
69. int main()  
70. {  
71.   
72.     FactoryB fa;                            //抽象工厂模式  
73.     AbstractPruduct* ap=fa.createProduct();  
74.     ap->print();  
75.     system("pause");  
76.     return 0;  
77. }  

实际工作中，需要配置一个ＸＭＬ配置文件，这样就可以与客户达到一个很好交互性，客户又不需要知道具体的逻辑实现，只需要配置文本文件，就能达到预期的效果了

三：单例模式

单例模式很常见，比如我们电脑的任务管理器就使用了单例模式。

当我们需要共享数据或需要数据同步的时候可以考虑使用单例模式。

具体代码如下：

[cpp]  view plain copy

1. #include<iostream>  
2. #include<string>  
3. #include<vector>  
4. using namespace std;  
5.   
6. class Singleton  
7. {  
8. public:  
9.     ~Singleton(){}  
10.       
11.     static Singleton* Instance();  
12. private:  
13.     Singleton(){cout<<"Singleton初始化"<<endl;}  
14.     static Singleton* st;  
15. };  
16.   
17.   
18. Singleton* Singleton::st=NULL;  
19.   
20. Singleton* Singleton::Instance()  
21. {  
22.     if(st==NULL)  
23.     {  
24.         st=new Singleton();  
25.     }  
26.   
27.     return st;  
28. }  
29.   
30. int main()  
31. {  
32.   
33.       
34.     Singleton *ss=Singleton::Instance();//单例模式  
35.   
36.     Singleton *sss=Singleton::Instance();//这里将用到上面的提供的指针  
37.     system("pause");  
38.     return 0;  
39. }