单例模式简单实现

#pragma once
#include <mutex>
#include <thread>
#include <iostream>
using namespace std;
//饿汉模式，类产生的时候就创建实例
class Singleton
{
public:
	static Singleton* GetInstance() {
		return &m_instance;
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
private:
	Singleton() {};
	static Singleton m_instance;
};
Singleton Singleton::m_instance;

//Meyers' Singleton
class Singleton2
{
private:
	Singleton(){};
	~Singleton(){};
	Singleton(const Singleton&){};
	Singleton& operator=(const Singleton&){};
public:
	static Singleton& getInstance(){
		static Singleton instance;
		return instance;
	}
}

//懒汉模式，用到的时候才实例化
class Singleton1
{
public:
	static Singleton1* GetInstance() {
		//保证性能，如果没有这个if，每个线程都得等锁
		if (m_Singleton1==nullptr)
		{
			m_mtx.lock();
			//保证只生成一个实例
			if (m_Singleton1 == nullptr) {
				m_Singleton1 = new Singleton1();
			}
			m_mtx.unlock();
		}
		return m_Singleton1;
	}
	//防止拷贝
	Singleton1(const Singleton1&) = delete;
	Singleton1& operator=(const Singleton1&) = delete;
	
private:
	Singleton1() { cout << "construct" << endl; }
	~Singleton1() { 
		cout << "destruct" << endl; 
	}
	static Singleton1* m_Singleton1;
	static mutex m_mtx;
	//定义一个用来释放内存的类
	class CGarbo {
	public:
		CGarbo() {};
		~CGarbo() {
			if (m_Singleton1 != nullptr)
			{
				delete m_Singleton1;
				m_Singleton1 = nullptr;
			}
		}
	};
	//定义一个释放内存类的静态对象
	//当该对象销毁时，就释放m_Singleton1指向的堆区资源
	static CGarbo m_garbo;
};
//static 成员变量必须在类声明的外部初始化.没有在类外初始化的 static 成员变量不能使用。
Singleton1* Singleton1::m_Singleton1 = nullptr;
mutex Singleton1::m_mtx;
Singleton1::CGarbo Singleton1::m_garbo;