C++单例设计

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;  //定义垃圾回收器对象