设计模式(C++实现)：simple factory pattern + singleton pattern

1简单工厂模式

简单工厂模式按照设计模式类型分的话是属于创建型模式，他是工厂模式中最简单的一种，他不属于GoF 23中设计模式之一，但是是简单实用的。他是有一个工厂对象来决定创建哪一种对象的实例。

实现比较简单，这里我只贴出类图和调用方法：

 

[cpp] view plaincopy

1. IProduct * simpleFactory::Create(std::string className)    
2. {    
3.     if( className == "Ipad")    
4.         return new Ipad();    
5.     if(className == "IPhone")    
6.         return new IPhone();    
7. }    

优点：外界只要传入类的名字或者识别符即可，不需要关心具体创建过程，只顾“消费”就可以了。各有各的指责和权力，分工明确，利于整个软件架构优化。

       

缺点：违反里高内聚责任分配原则，将全部逻辑放到一个工厂类中，如果需要支持新的类，那就必须改变工厂类了。

           这里只有一种工厂，一个系列的产品，那如果有多个系列的产品呢？问题如何解决？

应用场景：

1.        我的asp.net程序需要根据客户实际所用数据库来配置，那么我的程序支持所有的数据库，具体用到哪个，配置文件配置一下即可。这个C#/Java里的反射就可以实现。

2.        MFC里的Seralize功能。

2.单例模式，顾名思义，就是只能由一个实例，那么我们就必须保证

1. 该类不能被复制。
2. 该类不能被公开的创造。

那么对于C++来说，他的构造函数，拷贝构造函数和他的赋值函数都不能被公开调用。

但对于该私有的构造函数的构造时机上来说也可以分两种情况来构造：

1.  只有当需要该类的时候去构造（即为懒汉模式）
2.  在程序开始之前我就先构造好，你到时候直接用就可（即为饿汉模式）

那么我分别来说说这两种模式：

• 懒汉模式，静态局部变量只会被初始化一次即第一次执行的时候，其生命周期与程序的生命周期是相同的。这个同样适用于多线程的情况。

[cpp] view plaincopy

1. class single1    
2. {    
3. public:    
4.     static single1 &getInstance()    
5.     {    
6.         static single1 instance;    
7.         return instance;    
8.     }    
9.     
10.     void helloSingle() {cout<<"Hello Single1!"<<endl;}    
11. private:    
12.     single1(){};    
13.     single1(const single1&);    
14.     single1& operator=(const single1&);    
15.     
16. };  

• 饿汉模式，但是在main函数外面必须先调用其实例的构造，这个是静态实例的初始化，C/C++会保证其在进入main函数之前进行。 

[cpp] view plaincopy

1. class single2    
2. {    
3. public:    
4.     static single2* getInstance()    
5.     {    
6.         return mInstance;    
7.     }    
8.     
9.     void helloSingle() {cout<<"Hello Single2!"<<endl;}    
10.     
11. private:    
12.     static single2* mInstance;    
13.     
14. private:    
15.     single2(){};    
16.     single2(const single2&);    
17.     single2& operator=(const single2&);    
18.     
19. };    
20. single2* single2::mInstance = new single2;   

使用：

[cpp] view plaincopy

1. #include<iostream>  
2. using namespace std;  
3. class single1    
4. {    
5. public:    
6.     static single1 &getInstance()    
7.     {    
8.         static single1 instance;    
9.         return instance;    
10.     }    
11.     
12.     void helloSingle() {cout<<"Hello Single1!"<<endl;}    
13. private:    
14.     single1(){};    
15.     single1(const single1&);    
16.     single1& operator=(const single1&);    
17.     
18. };  
19. class single2    
20. {    
21. public:    
22.     static single2* getInstance()    
23.     {    
24.         return mInstance;    
25.     }    
26.     
27.     void helloSingle() {cout<<"Hello Single2!"<<endl;}    
28.     
29. private:    
30.     static single2* mInstance;    
31.     
32. private:    
33.     single2(){};    
34.     single2(const single2&);    
35.     single2& operator=(const single2&);    
36.     
37. };    
38. single2* single2::mInstance = new single2;      
39. int main()  
40. {  
41.     single1 *a=&single1::getInstance();  
42.     single2 *b=single2::getInstance();  
43.     a->helloSingle();  
44.     b->helloSingle();  
45.     return 0;  
46. }  

我们运用静态局部变量和静态实例的特性，使得我们的这两种模式都适用于多线程。