C++类的单例模式
zhanghuaichao 2018-03-06 17:03:00 45832 收藏 135
分类专栏： C/C++
三种单例模式转自博客：http://blog.csdn.net/q_l_s/article/details/52369065
简介
单例模式是使用广泛的一种设计模式，又称为单件模式、单子模式。其意图是保证一个类仅有一个实列，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多的地方都需要这样的功能模块，如系统的日志输出，操作系统只能有一个窗口管理器，一台pc连一个键盘等等。
单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象------也就是说除了一个全局实例外，仍然能创建相同类的本地实例
《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。
单例模式通过类本身来管理其唯一实例，这种特性提供了解决问题的方法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全局访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。习惯上把这个成员函数叫做Instance()，它的返回值是唯一实例的指针。
因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。
通过单例模式， 可以做到：
1. 确保一个类只有一个实例被建立
2. 提供了一个对对象的全局访问指针
3. 在不影响单例类的客户端的情况下允许将来有多个实例
懒汉式
懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。
创建
具体定义如下：
#include 运行结果截图：
从运行截图中，我们确实能看到实例的两个对象的地址都是一样的，也就是说明单例模式的实现是成功的。
注意：
单例类only有以下特征：
它有一个指向唯一实例的静态指针p，并且是私有的；
它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；
它的构造函数是私有的，这样就不能从别处创建该类的实例。
用户访问唯一实例的方法只有通过GetInstance()函数，如果不通过该函数，任何创建该实例的尝试都将失败，这是应为将类的构造函数定义为私有函数。
GetInstance()函数使用懒惰初始化，即它的返回值是这个函数首次被访问时创建的，这是一种防弹设计，即所有GetInstance()之后的调用都返回相同实例的指针。
eg：only *p1=only::GetInstance(); only *p2=p1->GetInstance();
安全释放实例
但是，问题来了，细心的朋友肯定会发现这样的一个问题：p指向的空间什么时候释放？该实例的析构函数又是什么时候执行呢？
如果类的析构函数中要有必要的行为规范，如：关闭文件，释放外部资源，那么上面的代码显然是无法满足要求的。这时候，我们需要使用一种方法，正常的删除实例，并对返回的指针调用delete操作。这样做可以实现功能，但不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。
一个妥善的方法是让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。
我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。
如下面的代码中的CGarbo类（Garbo意为垃圾工人）:
#include 运行结果截图：
从运行结果来看，确实达到我们删除实例的要求。
注意：
类CGarbo被定义为only的私有内嵌类，以防该类被在其他地方滥用。
程序运行结束时，系统会调用only的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。
使用这种方法释放单例对象有以下特征：
在单例类内部定义专有的嵌套类；
在单例类内定义私有的专门用于释放的静态成员；
利用程序在结束时析构全局变量的特性，选择最终的释放时机；
使用单例的代码不需要任何操作，不必关心对象的释放。
饿汉式
饿汉式的特点是一开始就加载了，如果说懒汉式是"时间换空间"，那么饿汉式就是"空间换时间"，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。饿汉式有两种常见的写法，写法1和写法2。
写法1
如下面这样，是有问题的：
class CSingleton
{
private:
CSingleton() {}
public:
static CSingleton * GetInstance()
{
static CSingleton instance;
return &instance;
}
};
这种写法不是线程安全的，因为静态的局部变量是在调用的时候分配到静态存储区，所以在编译的时候没有分配，
静态局部对象：
在程序执行到该对象的定义处时，创建对象并调用相应的构造函数！
如果在定义对象时没有提供初始指，则会暗中调用默认构造函数，如果没有默认构造函数，则自动初始化为0。
如果在定义对象时提供了初始值，则会暗中调用类型匹配的带参的构造函数（包括拷贝构造函数），如果没有定义这样的构造函数，编译器可能报错！
直到main（）结束后才会调用析构函数！
写法2
正确的写法应该像下面这样。
实例1：
// 单例类
class Singleton {
public:
// 获取此类的 唯一静态实例
static Singleton & getInstance() {
return instance;
}
// 公有函数部分
void func_print_1() {
cout << "1" << endl;
}
private:
// 私有化 默认构造函数 拷贝构造函数 析构函数
// 即 禁止对 class singleton 的类外构造和拷贝
Singleton() {
// 构造部分
};
Singleton(Singleton &b) {
// 此函数无用 因为已经私有化
// 相当于禁止了拷贝构造
};
~Singleton() {
// 析构部分
};
static Singleton instance;
};
//使用方法
int main(int argc, char *argv[]) {
// 由于私有化了 默认构造函数 以及 拷贝构造函数
// 所以只可以用引用方式 获取到单例类的实例
Singleton &A = Singleton::getInstance();
A.func_print_1();
system("pause");
return 0;
}
实例2：
class CMsBsGPSInfoStart
{
public:
static CMsBsGPSInfoStart& GetInstance();
protected:
CMsBsGPSInfoStart();
~CMsBsGPSInfoStart();
private:
static CMsBsGPSInfoStart _instance;
bool m_bMsBsGPSInfoStartFlag;
public:
bool GetMsBsGPSInfoStart();
bool SetMsBsGPSInfoStart(bool bIsStart);
};
CMsBsGPSInfoStart CMsBsGPSInfoStart::_instance;
CMsBsGPSInfoStart::CMsBsGPSInfoStart() : m_bMsBsGPSInfoStartFlag(false)
{
std::cout << "enter CMsBsGPSInfoStart::CMsBsGPSInfoStart() " << endl;
}
CMsBsGPSInfoStart::~CMsBsGPSInfoStart()
{
std::cout << "enter CMsBsGPSInfoStart::~CMsBsGPSInfoStart() " << endl;
}
CMsBsGPSInfoStart& CMsBsGPSInfoStart::GetInstance()
{
std::cout << "CMsBsGPSInfoStart::GetInstance()" << endl;
return _instance;
}
bool CMsBsGPSInfoStart::SetMsBsGPSInfoStart(bool bIsStart)
{
m_bMsBsGPSInfoStartFlag = bIsStart;
return true;
}
//我在主函数中包含头文件 instancetest.h后，主函数里什么也没有做
#include"instancetest.h"
using namespace::std;
int main()
{
return 0;
}
直接生成exe进行调试
调试结果如下，这就证明在没有调用Getinstance的时候已经执行了构造函数。
多线程下的懒汉单例模式
懒汉式存在的问题
在懒汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用GetInstance方法，这时执行 m_pInstance == NULL 肯定为真，然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，不满足单例类的定义了，所以懒汉式的写法会出现线程安全的问题！在多线程环境下，要对其进行修改。
class Singleton
{
private:
static Singleton* m_instance;
Singleton(){}
public:
static Singleton* getInstance();
};
Singleton* Singleton::getInstance()
{
if(NULL == m_instance)
{
Lock();//借用其它类来实现，如boost
if(NULL == m_instance)
{
m_instance = new Singleton;
}
UnLock();
}
return m_instance;
}
使用double-check来保证thread safety.但是如果处理大量数据时，该锁才成为严重的性能瓶颈。
懒汉模式的测试代码
大致代码如下：
class sun :public son
{
public:
~sun() {std::cout << "sun::~sun()";}
public:
static sun * GetInstance();
private:
sun(int a, int b, int c, double m, int d);
static sun * m_instance;
};
#include"instance.h"
sun * sun::m_instance(NULL);
sun::sun(int a, int b, int c, double m, int d) :son(a, b, c, m, d)
{
std::cout << "sun::sun"<<endl;
}
sun * sun::GetInstance()
{
if (NULL == m_instance)
{
m_instance = new sun(5,6,7,8.2,10);
}
return m_instance;
}
//然后主函数如下：
#include"instance.h"
//#include"instancetest.h"
using namespace::std;
int main()
{
sun * test = sun::GetInstance();
return 0;
}
运行结果如下所示：
这就是懒汉模式，用到的时候，才去调用，然后才会进行构造函数的调用，该模式下是线程不安全的。
深入的理解下懒汉和饿汉
其实就是看定义的事静态成员对象变量还是静态成员对象指针变量，因为如果定义了静态成员对象变量，程序在运行之初已经分配了空间，就要调用构造函数了，而你在调用getinstance的时候，不会再调用构造函数了，因为之前已经调用过了，你就是用的现成的，就是所谓的饿汉模式，上来先把吃的准备好了，因为饿怕了，怕后期准备会挨饿。
而定义了静态成员对象指针变量，程序运行之初也会分配空间，但是那个是指针的空间，而不是对象的空间，所以不会调用对象的构造函数，而只有调用getinstance进行new操作的时候，才会对其调用构造函数，就是现上轿现扎耳朵眼，比较懒惰，所以叫懒汉模式。