C++单例模式

单例模式

1：什么是单例

我的理解：在程序运行期间，只构造一个实例，所有的使用都共享使用该实例

2：如何实现单例

单例的特性：

​ 1：全局唯一的对象 ==》用static成员变量或者作用域特性实现

​ 2：不允许用户去构造 ==》禁用构造函数，但是要保证自己能调用

​ 3：只提供相应的接口，不允许用户修改 ==》禁用相关的拷贝构造等

​ 4：多线程要安全，资源的释放 ==》加锁，同一作用域static对象释放在程序运行结束时调用对应的析构函数

利用static特性，实现单例模式.
	1：静态成员为所有对象共享，不属于某个单个实例
	2：静态成员必须在类外定义，不需要加static，声明时已经加过
	3：类静态成员即可用类名::静态成员或者对象.静态成员来访问
	4：静态成员函数没有隐藏的this指针，不能访问任何非静态成员
	5：静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

单例的实现主要依赖static的特性实现！！！

3：编码实现

1: 在栈上控制内存的申请与释放，借助static特性（所有对象共享，不属于某个实例），实现懒汉和饿汉两种模式的单例

饿汉：

#include <iostream>
using namespace std;

class Singleton{
private:
	Singleton() = default;
	Singleton(const Singleton & s) = delete;
	Singleton &operator = (const Singleton &s) = delete;
	~Singleton(){};
private:
	static Singleton m_sig;

public:
	static Singleton * GetInstence()
	{
		return &m_sig;
	}

	void Print()
	{
		cout<<"Singleton Instence\n ";
	}
};

Singleton Singleton::m_sig; //饿汉

int main()
{
	Singleton::GetInstence()->Print();
	return 0;
}

懒汉： static为整个类服务，而不是某个对象，只初始化一次，而且生命周期延长到整个程序运行结束才释放，全局数据区分配内存

​ 修饰全局变量时，只能在本文件访问

#include <iostream>
using namespace std;

class Singleton{
private:
	Singleton() = default;
	Singleton(const Singleton & s) = delete;
	Singleton &operator = (const Singleton &s) = delete;
	~Singleton(){};

public:
	static Singleton * GetInstence() //调用这个函数的时候static生效了
	{
		static Singleton m_sig;
		return &m_sig;
	}

	void Print()
	{
		cout<<"Singleton Instence\n ";
	}
};

int main()
{
	Singleton::GetInstence()->Print();
	return 0;
}

2：可以利用static的特性，申请堆内存，相关的实现如下：

如下代码，借助static管理堆内存，但明显发现，new出来的资源是没有释放的，

#include <iostream>
#include <mutex>
using namespace std;

class Singleton{
private:
	Singleton() = default;
	Singleton(const Singleton & s) = delete;
	Singleton &operator = (const Singleton &s) = delete;
	~Singleton(){};

public:
	//对静态成员操作，所以控制成static
	static Singleton * GetInstence()
	{
		if(Singleton::m_sig_instance == NULL)
		{
			m_mutex.lock();
			if(Singleton::m_sig_instance == NULL)
			{
				m_sig_instance = new Singleton();
			}
			m_mutex.unlock();
		}
	}

	void Print()
	{
		cout<<"Singleton Instence.\n ";
	}

private:
	static Singleton * m_sig_instance;
	static std::mutex m_mutex;
};

Singleton * Singleton::m_sig_instance = NULL;
std::mutex Singleton::m_mutex;
int main()
{
	Singleton::GetInstence()->Print();
	return 0;
}

借助static的栈内存特性和类的作用域会调用析构函数，在类的作用域内用static特性实现资源的释放：

#include <iostream>
#include <mutex>
using namespace std;

class Singleton{
private:
	Singleton() = default;
	Singleton(const Singleton & s) = delete;
	Singleton &operator = (const Singleton &s) = delete;
	~Singleton(){};

	class FreeSingleton
	{
		public:
			~FreeSingleton()
			{
				cout<<"start free singletion \n";
				if(m_sig_instance != NULL)
				{
					cout<<"free singletion \n";
					delete m_sig_instance;
					m_sig_instance = NULL;
				}
			}
	};

public:
	//对静态成员操作，所以控制成static
	static Singleton * GetInstence()
	{
		if(Singleton::m_sig_instance == NULL)
		{
			m_mutex.lock();
			if(Singleton::m_sig_instance == NULL)
			{
				m_sig_instance = new Singleton();
			}
			m_mutex.unlock();
		}
	}

	void Print()
	{
		cout<<"Singleton Instence.\n ";
	}

private:
	static Singleton * m_sig_instance;
	static std::mutex m_mutex;
	static FreeSingleton m_freed;

};

Singleton * Singleton::m_sig_instance = NULL;
std::mutex Singleton::m_mutex;
//借助static 栈的特性，通过析构释放对应的内存 注意这里的类型和static变量的作用域取值
Singleton::FreeSingleton Singleton::m_freed; 

int main()
{
	Singleton::GetInstence()->Print();
	return 0;
}