特殊类设计

1. 请设计一个类，只能在堆上创建对象
实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

//只能在堆上创建对象的类
// 1. 构造函数私有
// 2. 提供一个静态的堆上创建对象的方法
// 3. 防拷贝(拷贝构造声明为私有，且不实现， 或者声明为delete函数）
class HeapOnly
{
public:
	static HeapOnly* getInstance()
	{
		//堆上创建对象
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}

	//HeapOnly(const HeapOnly& ho);
	HeapOnly(const HeapOnly& ho) = delete;
};

//HeapOnly g;
void test()
{
	//HeapOnly ho;

	HeapOnly* ptr = HeapOnly::getInstance();

	//HeapOnly copy(*ptr);
}

2.只在栈上创建对象的类

//只能在栈上创建对象的类
// a.
// 1. 构造函数私有
// 2. 提供一个公有的静态的栈上创建对象的方法
class StackOnly
{
public:
	static StackOnly getInstance()
	{
		return StackOnly();
	}
private:
	StackOnly() {};
};

//StackOnly so;
void testStackOnly()
{
	//StackOnly* ptr = new StackOnly;
	StackOnly so = StackOnly::getInstance();
}

//只能在栈上创建对象的类
// b.
// 1. 构造函数私有
// 2. 提供一个公有的静态的栈上创建对象的方法
// 3. 把operator new函数声明为delete函数
class StackOnly2
{
public:
	static StackOnly2 getInstance()
	{
		return StackOnly2();
	}
	void* operator new(size_t n) = delete;
private:
	StackOnly2() {};
};

3.禁止拷贝的类

//禁止拷贝的类
// 拷贝构造和赋值运算符声明为delete函数， 或者声明为私有的，且不实现
class NoCopy
{
public:
	NoCopy() {};
private:
	/*NoCopy(const NoCopy& nc);
	NoCopy& operator=(const NoCopy& nc);*/

	NoCopy(const NoCopy& nc) = delete;
	NoCopy& operator=(const NoCopy& nc) = delete;
};

4.不能被继承的类

//不能被继承的类
//1. 父类的构造声明为私有的

class NoH
{
private:
	NoH() {};
};

//或者父类定义为final类
class NoH2 final
{};

//class sub : public NoH
class sub /*: public NoH2*/
{
};

5.单例模式
一个类只能创建一个对象，即所谓得单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。（更多的将其用在对资源的保护上）

• 饿汉模式
  就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
  特点： 实现简单， 多线程情景下效率高。
  缺点： 程序启动慢， 多个单例对象初始化的顺序无法控制。

class singleton
{
public:
	static singleton* getInstance()
	{
		return &_single;
	}
private:
	//构造函数私有
	singleton() {};

	//防拷贝
	singleton(const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;

	static singleton _single;
};

//静态成员的初始化
singleton singleton::_single;

• 懒汉模式
  等你用的时候我在给你创建。
  特点： 延迟加载，程序启动块，可以指定多个单例对象的初始化顺序。
  缺点：实现复杂。

class singleton2
{
public:
	static singleton2* getInstance()
	{
		//双检查
		if (_ptr == nullptr)
		{
			_mtx.lock();
			if (_ptr == nullptr)
			{
				//第一次调用，创建对象
				_ptr = new singleton2;
			}
			_mtx.unlock();
		}
		return _ptr;
	}

	//删除函数可写可不写，因为静态变量在函数周期结束时会自动释放
	class GC
	{
	public:
		~GC()
		{
			if (_ptr)
				delete _ptr;
		}
	};

private:
	singleton2() {};

	//防拷贝
	singleton2(const singleton2&) = delete;
	singleton2& operator=(const singleton2&) = delete;

	static singleton2* _ptr;
	static mutex _mtx;
	static GC _gc;
};

singleton2* singleton2::_ptr = nullptr;
mutex singleton2::_mtx;
singleton2::GC singleton2::_gc;