C++的三种单例模式
简介
因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。
通过单例模式， 可以做到：
1. 确保一个类只有一个实例被建立
2. 提供了一个对对象的全局访问指针
3. 在不影响单例类的客户端的情况下允许将来有多个实例
懒汉式
懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。。。。。。
class CSingleton{public:static CSingleton* GetInstance(){if ( m_pInstance == NULL )m_pInstance = new CSingleton();return m_pInstance;}private:CSingleton(){};static CSingleton * m_pInstance;};
GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针：
CSingleton* p1 = CSingleton :: GetInstance();
CSingleton* p2 = p1->GetInstance();
CSingleton & ref = * CSingleton :: GetInstance();
对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。
饿汉式
饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。饿汉式有两种常见的写法，写法1和写法2
写法1如下面这样，是有问题的
class CSingleton{private:CSingleton(){}public:static CSingleton * GetInstance(){static CSingleton instance;return &instance;}};
这种写法不是线程安全的，因为静态的局部变量是在调用的时候分配到静态存储区，所以在编译的时候没有分配，
静态局部对象：
在程序执行到该对象的定义处时，创建对象并调用相应的构造函数！
如果在定义对象时没有提供初始指，则会暗中调用默认构造函数，如果没有默认构造函数，则自动初始化为0。
如果在定义对象时提供了初始值，则会暗中调用类型匹配的带参的构造函数（包括拷贝构造函数），如果没有定义这样的构造函数，编译器可能报错！
直到main（）结束后才会调用析构函数！
正确的写法应该像下面这样。
class CMsBsGPSInfoStart{public:static CMsBsGPSInfoStart& GetInstance();protected:CMsBsGPSInfoStart();~CMsBsGPSInfoStart();private:static CMsBsGPSInfoStart _instance;private://CLock m_lkMsBsGPSInfoStartFlag;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的时候，不会再调用构造函数了，因为之前已经调用过了，你就是用的现成的，就是所谓的饿汉模式，上来先把吃的准备好了，因为饿怕了，怕后期准备会挨饿。
而定义了静态成员对象指针变量，程序运行之初也会分配空间，但是那个是指针的空间，而不是对象的空间，所以不会调用对象的构造函数，而只有调用getinstance进行new操作的时候，才会对其调用构造函数，就是现上轿现扎耳朵眼，比较懒惰，所以叫懒汉模式。
懒汉式存在的问题：
在懒汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用GetInstance方法，这时执行 m_pInstance == NULL 肯定为真，然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，不满足单例类的定义了，所以懒汉式的写法会出现线程安全的问题！在多线程环境下，要对其进行修改。
多线程下的懒汉单例模式
这里要处理的是懒汉模式。
class Singleton{private:static Singleton* m_instance;Singleton(){}public:static Singleton* getInstance();};Singleton* Singleton::getInstance(){if(NULL == m_instance){Lock();//借用其它类来实现，如boostif(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;}
运行结果如下所示：
这就是懒汉模式，用到的时候，才去调用，然后才会进行构造函数的调用，该模式下是线程不安全的。