一、 预备知识 首先解决一个问题“如何访问私有静态成员变量”
- 定义并初始化私有静态成员变量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();
