单例模式

单例模式

单例模式的特点就是对象唯一。只能创建一个对象，想必应该在思考，如何才能创建一个（new Singleton）而且只能new 一个,且要保证他的唯一性（一个对象）。一个类只有一个对象，我们必须将构造函数私有化，这样就没有权限。但这也就是说，这个类必须实例化，不是由我们去实例化，所以这必须使用的是静态方法 ，值得一提的是，我想写一下为什么要隐藏析构函数（这不是必须的）,我们知道析构函数的目的是清理结束这个对象。释放他的一些资源。

~Director()
{
	delete  s_director;
}

为什么在单例模式下不能在析构函数中怎么干。delete new 是一对运算符，调用delete的话，会自动调用析构函数，在析构函数中调用析构函数这不就是死循环吗！所以我们需要自己写一个释放函数

#pragma once
#include<iostream>
class Director
{
public:
	static Director* getInstance();
	int  getID()const;
	//~Director()
	//{

	//	// delete  s_director		//      能这样吗？
	//}

	static void Free();
private:
	int m_ID;
	Director() {
		m_ID = 1;
	}                 // 为什么一定要将构造函数的权限为私有的

	~Director()
	{

		std::cout << "释放~Director()" << std::endl;
	}

	static Director* s_director;
};

#include "Director.h"

Director* Director::s_director = new Director;

Director* Director::getInstance()
{
	if (s_director == nullptr)
	{
		s_director = new Director;
	}

	return s_director;
}
int Director::getID()const
{
	return this->m_ID;
}


void Director::Free()
{
	if (s_director == nullptr)
	{
		std::cout << "释放失败" << std::endl;
		return;
	}
	delete s_director;
	s_director = nullptr;
	std::cout << "释放成功" << std::endl;
}

#include"Director.h"
#include<iostream>
using namespace std;


int main(int argc, char ** argv)
{
	auto dir = Director::getInstance();
	
	cout << dir->getID() << endl;

	auto dir2 = Director::getInstance();

	cout << dir2->getID() << endl;

	cout << dir << " " << dir2 << endl;   //  可以看出他们指向的同一片内存

	Director::Free();

	return 0;
}

以上属于饿汉模式。如果没有使用到这个不就造成资源浪费了吗

#pragma once
#include<iostream>
class Director
{
public:
	static Director* getInstance();
	int  getID()const;
	//~Director()
	//{

	//	// delete  s_director		//      能这样吗？
	//}

	static void Free();
private:
	int m_ID;
	Director() {
		m_ID = 1;
	}                 // 为什么一定要将构造函数的权限为私有的

	~Director()
	{

		std::cout << "释放~Director()" << std::endl;
	}

	static Director* s_director;
};

#include "Director.h"

Director* Director::s_director = nullptr;

Director* Director::getInstance()
{
	if (s_director == nullptr)
	{
		s_director = new Director;
	}

	return s_director;
}
int Director::getID()const
{
	return this->m_ID;
}


void Director::Free()
{
	if (s_director == nullptr)
	{
		std::cout << "释放失败" << std::endl;
		return;
	}
	delete s_director;
	s_director = nullptr;
	std::cout << "释放成功" << std::endl;
}

以上属于懒汉，需要是才实例化，这种写法有个致命的问题，就是多线程的安全问题。假设对象还没被实例化，然后有两个线程同时访问，那么就可能出现多次实例化的结果。