《设计模式》学习笔记——单例模式

单例模式（SingletonPattern）是一种对象创建模型，使用单例模式可以保证一个类只生成一个对象实例，即在整个程序的生命周期内，该类的实例对象只存在一个。
单例模式（SingletonPattern）保证一个类只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

实现单例模式的常用步骤：
        1、构造函数私有化

        2、提供一个全局的静态方法（全局访问点）

        3、 在类中定义一个静态指针，指向本类的变量的静态变量指针

单例模式的实现可以分为饿汉式和懒汉式两种（LazySingletonPattern、HungrySingletonPattern）。懒汉式的单例实现在多线程情况下容易出现异常，解决方法是利用线程锁进行线程同步。

HungrySingletonPattern.h

#pragma once
#include<iostream>

class HungrySingletonPattern
{
public:
	static HungrySingletonPattern* getInstance()		// 静态全局访问点
	{
		return m_hungrySing_p;
	};
	static void freeInstance()		// 静态全局访问点
	{
		if (m_hungrySing_p != nullptr)
		{
			delete m_hungrySing_p;
			m_hungrySing_p = nullptr;
		}
	};
	~HungrySingletonPattern();
private:
	static HungrySingletonPattern* m_hungrySing_p;
	HungrySingletonPattern();
};

 

LazySingletonPattern.h

#pragma once
class LazySingletonPattern
{
public:
	static LazySingletonPattern* getInstance()		// 静态全局访问点
	{
		if (m_lazySing_p = nullptr)
		{
			m_lazySing_p = new LazySingletonPattern;
		}
		return m_lazySing_p;
	};
	static void freeInstance()		// 静态全局访问点
	{
		if (m_lazySing_p != nullptr)
		{
			delete m_lazySing_p;
			m_lazySing_p = nullptr;
		}
	};
	~LazySingletonPattern();
private:
	static LazySingletonPattern* m_lazySing_p;
	LazySingletonPattern();
protected:
};

 

HungrySingletonPattern.cpp

#include "HungrySingletonPattern.h"
#include<iostream>


HungrySingletonPattern::HungrySingletonPattern()
{
	std::cout << "HungrySingletonPattern()执行" << std::endl;
}


HungrySingletonPattern::~HungrySingletonPattern()
{
	std::cout << "~HungrySingletonPattern()执行" << std::endl;
}

 

LazySingletonPattern.cpp

#include "LazySingletonPattern.h"
#include<iostream>

LazySingletonPattern::LazySingletonPattern()
{
	std::cout << "LazySingletonPattern()执行" << std::endl;
}


LazySingletonPattern::~LazySingletonPattern()
{
	std::cout << "~LazySingletonPattern()执行" << std::endl;
}

 

mainTest.cpp

#include<iostream>
#include"LazySingletonPattern.h"
#include "HungrySingletonPattern.h"

LazySingletonPattern* LazySingletonPattern::m_lazySing_p = nullptr;		//懒汉式
HungrySingletonPattern* HungrySingletonPattern::m_hungrySing_p = new HungrySingletonPattern;		//饿汉式

int main(void)
{
	LazySingletonPattern* lazySing_p1 = LazySingletonPattern::getInstance();
	LazySingletonPattern* lazySing_p2 = LazySingletonPattern::getInstance();

	HungrySingletonPattern* lazySing_p3 = HungrySingletonPattern::getInstance();
	HungrySingletonPattern* lazySing_p4 = HungrySingletonPattern::getInstance();

	if (lazySing_p1 == lazySing_p2)
	{
		std::cout << "相等" << std::endl;
	}
	LazySingletonPattern::freeInstance();
	

	if (lazySing_p3 == lazySing_p4)
	{
		std::cout << "相等" << std::endl;
	}
	HungrySingletonPattern::freeInstance();

	system("pause");
	return 0;
}