C++设计模式学习-单例模式

在转载的基础做了些修改

简介
因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。

通过单例模式， 可以做到：

1. 确保一个类只有一个实例被建立
2. 提供了一个对对象的全局访问指针
3. 在不影响单例类的客户端的情况下允许将来有多个实例

懒汉式
懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。

下面是我修改之后的代码

class CSingleton  
{  
public:  
	static CSingleton* GetInstance()  
	{  
		cout<<"GetInstance()"<<endl; 
		if (m_pInstance == NULL)    
			m_pInstance = new CSingleton();  
		return m_pInstance; 
	}  
    CSingleton(){
		cout<<"CSingleton()"<<endl;
	}
	 
	~CSingleton(){
		cout<<"~CSingleton()"<<endl;
	}
private: 
    static CSingleton * m_pInstance; 
};

GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针：
CSingleton* p1 = CSingleton :: GetInstance();
CSingleton* p2 = p1->GetInstance();
CSingleton & ref = * CSingleton :: GetInstance();

对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。

饿汉式
饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。

下面是修改之后的代码

class CSingleton_1  
{  
public:  
	static CSingleton_1& GetInstance()  
	{     
		return  m1_pInstance;
	}   
    CSingleton_1(){
		cout<<"CSingleton_1()"<<endl;
	}
	 
	~CSingleton_1(){
		cout<<"~CSingleton_1()"<<endl;
	} 
private:  	
	static CSingleton_1 m1_pInstance;
};   

在饿汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用GetInstance方法，这时执行 m_pInstance == NULL 肯定为真，然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，不满足单例类的定义了，所以饿汉式的写法会出现线程安全的问题！在多线程环境下，要对其进行修改。

下面是测试代码

#include<iostream>
#include"single.h"
using namespace std;
using namespace test;
CSingleton_1 CSingleton_1::m1_pInstance;
CSingleton* CSingleton::m_pInstance;

int main()
{
	return 0;
}

结果：

多线程下的单例模式
这里要处理的是懒汉模式。

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.但是如果处理大量数据时，该锁才成为严重的性能瓶颈。

下面对文章中提到的进行下简单的总结和分析：

1.深入的理解下懒汉和饿汉

其实就是看定义的事静态成员对象变量还是静态成员对象指针变量，因为如果定义了静态成员对象变量，程序在运行之初已经分配了空间，就要调用构造函数了，而你在调用getinstance的时候，不会再调用构造函数了，因为之前已经调用过了，你就是用的现成的，就是所谓的饿汉模式，上来先把吃的准备好了，因为饿怕了，怕后期准备会挨饿。

而定义了静态成员对象指针变量，程序运行之初也会分配空间，但是那个是指针的空间，而不是对象的空间，所以不会调用对象的构造函数，而只有调用getinstance进行new操作的时候，才会对其调用构造函数，就是现上轿现扎耳朵眼，比较懒惰，所以叫懒汉模式。

这里我写了两个小例子，大家看到例子就更清楚了。在3中进行展示

2.文中有一处书写错误。

在饿汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用GetInstance方法，这时执行 m_pInstance == NULL 肯定为真，然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，不满足单例类的定义了，所以饿汉式的写法会出现线程安全的问题！在多线程环境下，要对其进行修改。

-----这里的恶汉应该改成懒汉

3.楼主写的恶汉代码有点问题，正常的代码应该是下面这样，和楼主的区别在于（楼主的代码是线程不安全的，因为静态的局部变量是在调用的时候分配到静态存储区，所以在编译的时候没有分配）

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;
}

这就证明在没有调用Getinstance的时候已经执行了构造函数。

恶汉模式的测试代码如下，大致代码如下：

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;
}

这就是懒汉模式，用到的时候，才去调用，然后才会进行构造函数的调用，该模式下是线程不安全的。

4.对于楼主写的恶汉模式有问题的原因具体解释如下：

静态局部对象：
在程序执行到该对象的定义处时，创建对象并调用相应的构造函数！
如果在定义对象时没有提供初始指，则会暗中调用默认构造函数，如果没有默认构造函数，则自动初始化为0。
如果在定义对象时提供了初始值，则会暗中调用类型匹配的带参的构造函数（包括拷贝构造函数），如果没有定义这样的构造函数，编译器可能报错！
直到main（）结束后才会调用析构函数！

作者：撒哈拉的水草
链接：https://www.zhihu.com/question/40693991/answer/87843670
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。