【设计模式】01 单例模式

1、单例模式

概念：单例模式是一种常用的软件设计模式。它的核心结构只包含一个被称为单例的特殊类。它的目的是保证一个类仅有一个实例。
应用场景：有一些对象只需要一个，如：一台PC连接一个键盘、任务管理器只能打开一个。

其构建步骤：

（1）把构造函数私有化；

（2）增加静态的、私有的 类的指针变量；

（3）提供静态的对外接口，可以让用户获得单例对象。

class A
{
private:
	//1、把构造函数私有化
	A()
	{	
		a = new A;
	}

private:
	//2、增加静态的、私有的 类的指针变量
	static A* a;
public:
	//3、提供静态的对外接口，可以让用户获得单例对象
	static A* getInstance()
	{
		return a;
	}
};

//静态属性，类外初始化
A* A::a = NULL;

2、赖汉式

懒汉：第一次用到类的实例的时候才回去实例化

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

赖汉式碰到多线程，是线程不安全的。

class Singleton_lazy
{
private:
	Singleton_lazy()
	{
	}

public:
	static Singleton_lazy* getInstance()
	{
		if (pSingle == NULL)
		{
			pSingle = new Singleton_lazy;
		}
		return pSingle;
	}
private:
	static Singleton_lazy* pSingle;
};
//静态成员类外初始化
Singleton_lazy* Singleton_lazy::pSingle = NULL;

3、饿汉式

饿汉：单例类定义的时候就进行实例化

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

class Singleton_lazy
{
private:
	Singleton_lazy()
	{
	}
 
public:
	static Singleton_lazy* getInstance()
	{
		return pSingle;
	}
private:
	static Singleton_lazy* pSingle;
};
// 静态成员类外初始化
Singleton_lazy* Singleton_lazy::pSingle = new Singleton_lazy;

饿汉式碰到多线程，是线程安全的。

class Singleton_hungry
{
private:
	Singleton_hungry()
	{
		
	}

public:
	static Singleton_hungry* getInstance()
	{
		return pSingle;
	}
/********************************************************************************************************/
//单例模式 释放  不能提供这样的函数，只有一个，不会一直new，一直delete
#if 0
	static void freeSpace()
	{
		if (pSingle != NULL)
		{
			delete pSingle;
			pSingle = NULL;
		}
	}
#endif

	//增加嵌套类
	class Garbo 
	{
		~Garbo()
		{
			if (pSingle != NULL)
			{
				delete pSingle;
			}
		}
	};


private:
	static Singleton_hungry* pSingle;
	static Garbo garbo;
};
//静态成员类外初始化
Singleton_hungry* Singleton_hungry::pSingle = new Singleton_hungry;

4、测试

void test01()
{
	Singleton_lazy* p1 = Singleton_lazy::getInstance();
	Singleton_lazy* p2 = Singleton_lazy::getInstance();

	if (p1 == p2)
	{
		cout << "两个指针指向同一片内存，是单例模式" << endl;
	}
	else
	{
		cout << "两个指针没有指向同一片内存，不是单例模式" << endl;
	}


	Singleton_hungry* p3 = Singleton_hungry::getInstance();
	Singleton_hungry* p4 = Singleton_hungry::getInstance();
	if (p3 == p4)
	{
		cout << "两个指针指向同一片内存，是单例模式" << endl;
	}
	else
	{
		cout << "两个指针没有指向同一片内存，不是单例模式" << endl;
	}
}

完整代码

#include <iostream>
using namespace std;

//单例模式---赖汉式
class SingleTon1 {
private:
	SingleTon1() {}

private:
	static SingleTon1* p;
	
public:
	static SingleTon1* getInstance() {
		if (p == NULL) {
			p = new SingleTon1;
		}
		return p;
	}
};
SingleTon1* SingleTon1::p = NULL;

void test1() {
	SingleTon1* p1 = SingleTon1::getInstance();
	SingleTon1* p2 = SingleTon1::getInstance();
	if (p1 == p2) {
		cout << "单例模式---赖汉式" << endl;
	} else {
		cout << "不是单例模式---赖汉式" << endl;
	}
}

//单例模式---饿汉式
class SingleTon2 {
private:
	SingleTon2() {}

private:
	static SingleTon2* p;
	
public:
	static SingleTon2* getInstance() {
		return p;
	}
};
SingleTon2* SingleTon2::p = new SingleTon2;

void test2() {
	SingleTon2* p1 = SingleTon2::getInstance();
	SingleTon2* p2 = SingleTon2::getInstance();
	if (p1 == p2) {
		cout << "单例模式---饿汉式" << endl;
	} else {
		cout << "不是单例模式---饿汉式" << endl;
	}
}

int main()
{
	test1();
	test2();
	return 0;
}

5、释放对象

单例模式一般不提供释放的函数，因为对象只有一个，不会一直new、一直delete。不会占太多内存。

如果非要写这样的函数

参考如下

class Singleton_hungry
{
private:
	Singleton_hungry()
	{
		
	}

public:
	static Singleton_hungry* getInstance()
	{
		return pSingle;
	}
/********************************************************************************************************/
//单例模式 释放  不能提供这样的函数，只有一个，不会一直new、一直delete
#if 0
	static void freeSpace()
	{
		if (pSingle != NULL)
		{
			delete pSingle;
			pSingle = NULL;
		}
	}
#endif

	//增加嵌套类
	class Garbo 
	{
		~Garbo()
		{
			if (pSingle != NULL)
			{
				delete pSingle;
			}
		}
	};


private:
	static Singleton_hungry* pSingle;
	static Garbo garbo;
};
//静态成员类外初始化
Singleton_hungry* Singleton_hungry::pSingle = new Singleton_hungry;