【了解单例模式】

1、设计一个类，只能在堆上创建对象

方法：构造函数私有化
将构造函数私有化，拷贝构造也要私有化（若对堆上创建的对象进行解引用并调用拷贝构造，同样可以在栈上创建对像。）提供一个静态函数，静态函数完成堆上对象的创建。

class Test
{
	Test()
	{
		cout << "Test()" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}
	Test(const Test&);//拷贝构造
	/*c++11新用法：
	Test(const Test& t) = detele;   会使得拷贝构造函数无法生成，也就是告诉编译器将该函数删除掉。
	Test(const Test& t) = default;  告诉编译器，让编译器生成默认的函数*/
public:
	static Test* creat()
	{
		return new Test;//会调用构造函数
	}
};
int main1()
{
	//Test a;  //无法直接构造对象
	Test* a = Test::creat();//成功创建对象
	system("pause");
	return 0;
}

2、设计一个类，只能在栈上创建对象

方法：将new功能屏蔽掉，即私有operator new和定位new表达式。

class Tmp
{
	void* operator new(size_t size);
	void operator delete(void*p);
public:
	Tmp()
	{
		cout << "Tmp()" << endl;
	}
	~Tmp()
	{
	cout<<"~Tmp()"<<endl;
	}
};

3、单例模式

（1）什么是设计模式？
设计模式是一套被反复利用，多人知晓，经过分类的，代码设计经验总结。其目的是提高代码可重用性，使代码易于理解并真正工程化。
（2）描述一下设计模式之一的单例模式？
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
（3）单例模式的两种实现

• 饿汉模式（程序启动时就创建一个唯一的实例对象）

#include <iostream>
//锁和线程
#include <mutex>
#include <thread>

using namespace std;
//单例模式


//1、饿汉模式（先初始化再用）
class Single
{
public:
	static Single* GetInstance()  //只有静态成员函数可以访问静态成员变量
	{
		return &m_instance;
	}
private:
	Single();         //默认构造
	Single(Single const&) = delete;   //删除拷贝构造
	Single& operator=(Single const&) = delete;  //删除赋值运算符重载

	static Single m_instance;  //static类型的成员变量
};

Single Single::m_instance; // 在程序入口之前就完成单例对象实例化

优点：简单、线程安全
缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定

• 懒汉模式（在第一次使用实例对象时创建对象）

//2、懒汉模式（先用再初始化）
//因为使线程不安全的（在没有创建对象情况下，多个线程调用GeInstance()函数，并进入创建对象）
//所以要加锁

class Singleton
{
public:
	static Singleton* GetInstance() 
	{
		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (nullptr == m_pInstance) 
		{
			m_mtx.lock();
			if (nullptr == m_pInstance) 
			{
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
		return m_pInstance;
	}
	// 实现一个内嵌垃圾回收类
	class CGarbo 
	{
	public:
		~CGarbo()
		{
			if (Singleton::m_pInstance)//指针为空，就释放
				delete Singleton::m_pInstance;
		}
	};
	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;
private:
	// 构造函数私有
	Singleton(){};
	// 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);
	static Singleton* m_pInstance; // 单例对象指针
	static mutex m_mtx; //互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;

优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
缺点：复杂