三种单例模式的C++实现

通过单例模式，可以做到以下三点：

1.确保一个类只有一个实例被创建

2.提供了一个对对象全局访问的指针

3.在不影响单例类的客户端的情况下允许将来有多个实例

延迟式：

特点：延迟加载，也就是说直到实力类被用到的时候才会被加载

C++代码：

Singleton.h
#ifndef __C__Review__Singleton__
#define __C__Review__Singleton__

#include <iostream>
class Singleton{

private:
    
    Singleton() { }
    Singleton(const Singleton&);//⽆无实现
    Singleton& operator=(const Singleton&); //⽆无实现
    
    static Singleton *instance;
    
public:
    
    static Singleton *getInstance();
    static void release();
};
#endif /* defined(__C__Review__Singleton__) */

Singleton.cpp
#include "Singleton.h"
Singleton *Singleton::instance = 0;

Singleton* Singleton::getInstance()
{
    if(instance == nullptr)
        instance = new Singleton();
    return instance;
}

void Singleton::release()
{
    if (instance != NULL) {
        delete instance;
        instance = NULL;
    }
}

main.cpp
#include "Singleton.h"

using namespace std;

int main(int argc, const char * argv[]) {
    Singleton *s1 = Singleton::getInstance();
    cout<<s1<<endl;
    
    Singleton *s2 = Singleton::getInstance();
    cout<<s2<<endl;
    
    Singleton *s3 = Singleton::getInstance();
    cout<<s3<<endl;
    
    s1->release();
    s2->release();
    s3->release();
    return 0;
}

饥饿式：

特点：一开始就创建了实例，所以每次用到的之后直接返回就好

C++代码：

Singleton.h
#ifndef __C__Review__Singleton__
#define __C__Review__Singleton__

#include <iostream>

class Singleton{
    
private:
    
    Singleton(){}
    Singleton(const Singleton& other){}
    
    Singleton& operator=(const Singleton& other);
    
    static Singleton *instance;
    
public:
    
    static Singleton *getInstance();

};

#endif /* defined(__C__Review__Singleton__) */


Singleton.m

#include "Singleton.h"

Singleton *Singleton::instance = new Singleton();

Singleton* Singleton::getInstance()
{
    return instance;
}

main.cpp
#include "Singleton.h"

using namespace std;

int main(int argc, const char * argv[]) {
    Singleton *s1 = Singleton::getInstance();
    cout<<s1<<endl;
    
    Singleton *s2 = Singleton::getInstance();
    cout<<s2<<endl;
    
    Singleton *s3 = Singleton::getInstance();
    cout<<s3<<endl;
    
   
    return 0;
}

多线程式：

1. class Lock  
2. {  
3. private:         
4.     CCriticalSection m_cs;  
5. public:  
6.     Lock(CCriticalSection  cs) : m_cs(cs)  
7.     {  
8.         m_cs.Lock();  
9.     }  
10.     ~Lock()  
11.     {  
12.         m_cs.Unlock();  
13.     }  
14. };  
15.   
16. class Singleton  
17. {  
18. private:  
19.     Singleton();  
20.     Singleton(const Singleton &);  
21.     Singleton& operator = (const Singleton &);  
22.   
23. public:  
24.     static Singleton *Instantialize();  
25.     static Singleton *pInstance;  
26.     static CCriticalSection cs;  
27. };  
28.   
29. Singleton* Singleton::pInstance = 0;  
30.   
31. Singleton* Singleton::Instantialize()  
32. {  
33.     if(pInstance == NULL)  
34.     {   //double check  
35.         Lock lock(cs);           //用lock实现线程安全，用资源管理类，实现异常安全  
36.         //使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的无论是因为异常抛出还是语句块结束。  
37.         if(pInstance == NULL)  
38.         {  
39.             pInstance = new Singleton();  
40.         }  
41.     }  
42.     return pInstance;  
43. }