一文搞懂单例模式

一、预备知识首先解决一个问题“如何访问私有静态成员变量”

定义并初始化私有静态成员变量x

#include<iostream>
using namespace std;
class A{
private:
    static int x;
}
int A::x = 1;

在main函数中通过类来直接访问会出错

#include<iostream>
using namespace std;
class A{
private:
    static int x;
};
int A::x = 1;
void main(){
    cout << A::x;
    return;
}

error C2248: “A::x”: 无法访问private 成员(在“A”类中声明)

只能通过公有函数来访问

#include<iostream>
using namespace std;
class A{
private:
    static int x;
public:
    int getx(){
        return xx;
    }
};
int A::x = 1;
void main(){
    A a;
    cout << a.getx();
    return;
}

二单例模式
单例模式的动机是让类自身负责保存它的唯一实例，这个类可以保证没有其他实例被

创建，并且它提供一个访问该实例的方法。

解决方法：1、类的定义中含有一个该类的静态私有对象；
静态对象属于类，由类保存。
私有化的意义在于只能通过接口去访问，否则在饱汉模式下会出现对象为空的现象。如

#include<iostream>
using namespace std;
class Singleton{
private:
    Singleton(){};   
public:
    static Singleton *single; 
public:
    static Singleton *GetSingleton(){
    if(single == NULL){
        single = new Singleton;
    }
    return single;
    }
};
Singleton* Singleton::single = NULL;
void main(){
    Singleton *s2 = Singleton::single;
    Singleton *s1 = Singleton::GetSingleton();
    
    if(s1 == s2){
        cout<<"yes"<<endl;
    }else{
        cout<<"NO"<<endl; 
    }
}

其中s2为NULL；
2、私有化构造函数；
3、提供一个静态的公有函数用于创建或获取自身的静态私有对象。
如果不是这样，就需要实例化对象来调用函数进行这些操作，用一个对象去获取另一个唯一的对象明显是搞笑的。见章节一。

三多种实现方式
1、饱汉模式

#include<iostream>
using namespace std;
class Singleton{
private:
    Singleton(){};   //私有化构造函数
    static Singleton *single; //私有静态对象
public:
    static Singleton *GetSingleton(){ //公有静态返回函数
    if(single == NULL){
        single = new Singleton;
    }
    return single;
    }
};

Singleton* Singleton::single = NULL;

2、线程安全懒汉模式

#include<iostream>
using namespace std;
class Singleton{
private:
    Singleton(){};   
public:
    static Singleton *single; 
public:
    static Singleton *GetSingleton(){
    if(single == NULL){                      //注意是双重判断 防止每次访问都有加锁
        lock();
            if(single == NULL)
                single = new Singleton;
        unlock();
    }
    return single;
    }
};
Singleton* Singleton::single = NULL;

3、饿汉模式

#include<iostream>
using namespace std;

class Singleton{
private:
    Singleton(){};
    static Singleton* single;
public:
    static Singleton* get(){
        return single;
    }
};
Singleton* Singleton::single = new Singleton();

一文搞懂单例模式

推荐阅读更多精彩内容