单例模式

发表于 | 本文阅读数 次

单例模式就是保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例

饿汉模式

程序启动时就创建一个唯一的实例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
优点：简单
缺点：可能导致进程启动慢，且如果有多个单例类对象实例则启动顺序不确定（涉及到资源问题）
class singleton
{
    public:
    	static singleton* GetInstance()
        {
            return &m_instance;
        }
    private:
    	singleton(){}
    	singleton(const singleton&) = delete;
    	singleton& operator=(singleton const&) = delete;
    	static singleton m_instance;
}；

singleton singleton::m_instance;

懒汉模式

第一次使用实例对象时创建对象（延迟加载）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class singleton
{
    public:
    	//在外部调用singleton::GetInstance()时才会初始化对象
    	static singleton* GetInstance()
        {
            if(nullptr == m_pInstance){
                m_mtx.lock();
                if(nullptr == m_pInstance){
                    m_pInstance  new singleton();
                }
                m_mtx.unlock();
            }
            return m_pInstance;
        }
    
    	class CGarbo{
          public:
            ~CGarbo(){
                if(singleton::m_Instance)
                    delete singleton::m_Instance;
            }
        };
    
    //定义一个静态成员变量，在程序结束时系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;
    
    private:
    	singleton(){}
    	//防拷贝
    	singleton(const singleton&);
    	singleton operator=(const singleton&);
    
    	static singleton* m_pInstance;  //单例对象指针
    	static mutex m_mtx;				//互斥锁
};

singleton* singleton::m_pInstance = nullptr;
singleton::CGarbo Garbo;
mutex singleton::m_mtx;
0%