class test 
{
public:
	static test* GetObj() 
	{
		return new test();  //堆上申請并創建一個對象
	}
private:
	//構造函數私有
	test() { cout << "調用了構造函數" << endl; }
	//拷貝構造私有化，無法實例化對象
	test(const test& obj){};
};
void func1() 
{
	test* p = test::GetObj();  //通過調用靜態函數獲取對象的指針
}

//只能在棧上創建對象
class test1 
{
public:
	static test1 GetObj()
	{
		return test1(); //棧上創建一個對象并返回
	}
	test1() { cout << "調用了構造函數" << endl; }
private:
	//拷貝構造私有化無法實例化對象
	test1(const test1& obj) {  }
};

class test02 
{
public:
	test02() 
	{ }
private:
	//自定義的定位new、定位delete
	void *operator new(size_t size) 
	{ 
		//代碼....  
	}
	void operator delete(void *p)  
	{  
		//代碼....
	}
};

class CopyBan
{
 // ...
private:
 CopyBan(const CopyBan&);
 CopyBan& operator=(const CopyBan&);
 //...
};

class test
{
private:
	test(){}
}

class A final
{
 // ....
};

class Singleton 
{
public:
	static Singleton* GetInstance()
	{
		return obj;
	}
private:
	Singleton() {}
	Singleton(const Singleton& obj) {}
	static Singleton* obj;
};
Singleton* Singleton::obj = new Singlet	on; 

static Singleton* GetInstance()
{
	//如果只有一層的if判斷的我們的程序就會存在一定的問題，
	//在多線程的場景下，多個線程都是比較自由的，可讀可寫、或者只讀、只寫
	//這樣在一些場景下就會導致單例對象失去他本身的性質，
	//比如：兩個線程 th1、th2，同時進入到了if語句中，假設th1會先執行。
	//為obj 申請了一個對象并返回它的指針，難么這個實例對象也就創建了
	//最后return obj，th1結束后(不確定結束時間)，
	//th2又會再次new一個對象給obj,最后導致obj被賦值兩次
	//整個過程梳理：
	//1、th1線程存在內存泄漏，因為obj被賦值兩次，而第一次new出來的對象并沒有被釋放，那么就存在了內存泄漏
	//2、obj被賦值兩次，失去單例對象性質
	if (!obj) 
	{
		if (!obj) 
		{
			obj = new Singleton();
		}
	}
	return obj;  //返回對象的指針
}

static Singleton* GetInstance()
{
		//通過加鎖，保證了線程安全
		m_mtx.lock();  //加鎖
		//假設th1先拿到鎖，那么th1就會先執行下面的語句，而th2就會等待，
		//obj就會指向new出來的單例對象，最后th1解鎖完了return ,而th2
		//才剛拿到鎖繼續if判斷的時候obj已經有值了就會跳過if繼續往下執
		//行，然后解鎖最終return ,整個過程中單例對象只有一份，
		//不存在二次賦值
		if (!obj) 
		{
			obj = new Singleton();
		}
		m_mtx.unlock();  //解鎖
	return obj;  //返回對象的指針
}

static Singleton* GetInstance()
{
	if(!obj)  
		//第一次判斷保護線程安全，第二次obj已經有值，不需要執行{....}
		//優點：保證線程安全的同時完成了單例對象的初始化
	{
		m_mtx.lock();  //加鎖
		if (!obj)   //保證單例對象只有一份，不會存在二次賦值
		{
			obj = new Singleton();
		}
		m_mtx.unlock();  //解鎖
	}
	return obj;  //返回對象的指針
}

//懶漢
class Singleton 
{
public:
	class CGarbo {
	public:
		~CGarbo() {
			if (obj)   //釋放對象指針，并置空
			{
				delete obj;
				obj = nullptr;
			}
		}
	};
public:
	static Singleton* GetInstance()
	{
		//雙重檢查的好處是保護了線程安全，同時又提高了效率
		if (!obj) 
		{
			m_mtx.lock();  //加鎖
			if (!obj) 
			{
				obj = new Singleton();
			}
			m_mtx.unlock();  //解鎖
		}
		return obj;  //返回對象的指針
	}
private:
	Singleton()  {}
	Singleton(const Singleton& obj) {}
	void operator=(const Singleton& obj) {}
	static Singleton* obj; //聲明對象指針
	static mutex m_mtx; //聲明互斥鎖
	static CGarbo Garbo;  //聲明垃圾回收器對象
};
Singleton* Singleton::obj = nullptr;  //對象指針初始化
mutex Singleton::m_mtx;  //定義互斥鎖
Singleton::CGarbo Garbo;  //定義垃圾回收器對象