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

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

class HeapOnly
{
public:
	//提供一個static公有函數(shù)創(chuàng)建對象，對象創(chuàng)建的都在堆上
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly(){}

	//C++98 防拷貝 只聲明，不實現(xiàn)
	HeapOnly(const HeapOnly&);
	
	//C++11
	HeapOnly(const HeapOnly&) = delete;
};

class StackOnly
{
public:
	StackOnly(){}
public:
	//C++11
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	//C++98 防調(diào)用
	void* operator new(size_t size);
	void operator delete(void* p);
};

class StackOnly
{
public:
	StackOnly(){}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};

//C++98這種方式不夠直接
//這里是可以繼承的，但是Derive不能創(chuàng)建對象，因為Derive的構(gòu)造函數(shù)必須要調(diào)用父類NonOnherit構(gòu)造，但是NonInherit的構(gòu)造函數(shù)私有了，私有在子類不可見，那么這里繼承不會報錯，繼承的子類創(chuàng)建對象會報錯
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

class A final
{
	//...
};

//餓漢模式：main函數(shù)之前，一開始就創(chuàng)建對象
//全局只要唯一的Singleton實例對象，那么他里面的成員也就是單例的
class Singleton
{
public:
	//3.提供一個獲取單例對象的static成員函數(shù)
	static Singleton& GetInstance();

	//如果vector對象是私有，想訪問，只能再封裝一層
	//void PushBack(int x)
	//{
	//	_v.push_back(x);
	//}
	vector<int> _v;
private:
	//vector<int> _v;

	//1.構(gòu)造函數(shù)私有化，不能隨意創(chuàng)建對象
	Singleton()
	{}

	//防拷貝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//2.類里面聲明一個static Singleton對象，在cpp定義這個對象
	//保證全局只要一個唯一對象
	//這里的static類比的是全局變量，只是受類域的限制，沒有改變鏈接屬性
	static Singleton _sinst;
};

#include "Singleton.h"

//定義
Singleton Singleton::_sinst;

Singleton& Singleton::GetInstance()
{
	return _sinst;
}

//定義
Singleton* Singleton::_spinst = nullptr;
mutex Singleton::_mtx;

Singleton& Singleton::GetInstance()
{
	//雙檢查加鎖 提高效率
	if (_spinst == nullptr)
	{
		_mtx.lock();
		if (_spinst == nullptr)
		{
			//第一次調(diào)用
			_spinst = new Singleton;
		}
		_mtx.unlock();
	}

	return *_spinst;
}

void Singleton::DelInstance()
{
	if (_spinst != nullptr)
	{
		_mtx.lock();
		if (_spinst != nullptr)
		{
			delete _spinst;
			_spinst = nullptr;
		}
		_mtx.unlock();
	}
}

#pragma once
#include <vector>
#include <iostream>
#include <mutex>
using namespace std;

//懶漢模式：第一次調(diào)用GetInstance時，才會創(chuàng)建初始化單例對象
//相對于餓漢，不存在可能會導(dǎo)致啟動慢的問題，也可以控制順序依賴的問題了
class Singleton
{
public:
	//3.提供一個獲取單例對象的static成員函數(shù)
	static Singleton& GetInstance();

	//如果vector對象是私有，想訪問，只能再封裝一層
	//void PushBack(int x)
	//{
	//	_v.push_back(x);
	//}
	vector<int> _v;

		//或?qū)崿F(xiàn)一個內(nèi)嵌垃圾回收類
	class CGarbo {
	public:
		~CGarbo() {
			if (Singleton::_spinst)
				delete Singleton::_spinst;
		}
	};

	//定義一個靜態(tài)成員變量，程序結(jié)束時，系統(tǒng)會自動調(diào)用它的析構(gòu)函數(shù)從而釋放單例對象
	static CGarbo Garbo;
	
private:
	//vector<int> _v;

	//1.構(gòu)造函數(shù)私有化，不能隨意創(chuàng)建對象
	Singleton()
	{}

	//防拷貝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//2.類里面聲明一個static Singleton對象，在cpp定義這個對象
	//保證全局只要一個唯一對象
	static Singleton* _spinst;
	static mutex _mtx;
};