我所理解的设计模式（C++实现）——单例模式（Singleton Pattern）

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

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.     int helloSingle() {return 1;}  
  11. private:  
  12.   
  13. private:  
  14.     single1(){};  
  15.     single1(const single1&);  
  16.     single1& operator=(const single1&);  
  17.   
  18. };  

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

  1. class single2  
  2. {  
  3. public:  
  4.     static single2* getInstance()  
  5.     {  
  6.         return mInstance;  
  7.     }  
  8.   
  9.     int helloSingle() {return 1;}  
  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;  

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