特殊类设计

只能在堆上创建对象的类

1. 构造函数私有
2. 提供一个静态的堆上创建对象的方法
3. 防止拷贝（拷贝构造声明为私有且不实现，或者声明为delete）

class HeapOnly
{
public:
	static HeapOnly* getInstance()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{ }

	HeapOnly(const HeapOnly& H) = delete;
};

void testHeaponly()
{
	HeapOnly* ptr = HeapOnly::getInstance();
}

只能在栈上创建对象的类

1. 构造函数私有
2. 提供一个静态的栈上创建对象的方法

class StackOnly
{
public:
	static StackOnly getInstance()
	{
		return StackOnly();
	}
private:
	StackOnly()	{ }
};

void testStackOnly()
{
	StackOnly so = StackOnly::getInstance();
}

方法二：屏蔽new

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

对象不能被拷贝的类

将拷贝构造与赋值运算符声明为delete函数或者声明为私有且不实现

class CopyBan
{
public:
	CopyBan() { }
private:
	CopyBan(const CopyBan& cb) = delete;
	CopyBan& operator=(const CopyBan& cb) = delete;
};

不能被继承的类

1. 父类构造声明为私有

class NoSon
{
public:
private:
  NoSon() { }
}

1. 加上final关键字

class NoSon final
{ };

单例模式

一个类只能创建一个对象，该模式可以保证该类中只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享

饿汉模式

1. 构造函数私有
2. 提供一个静态的方法返回单例
3. 声明一个静态的单例成员
4. 拷贝构造和赋值声明为delete函数

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;

特点：实现简单，多线程情境下效率高

缺陷：程序启动比较满，多个单例对象初始化的顺序无法控制

懒汉模式

1. 构造函数私有
2. 提供一个静态的方法返回单例，第一次调用创建对象，后续调用直接返回
3. 声明一个静态指针，指针初始化为nullptr
4. 拷贝构造和赋值声明为delete
5. 保证线程安全（修改指针），双检查提高效率

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

	class GC
	{
		~GC()
		{
			if(_ptr)
				delete _ptr;
		}
	};
private:
	Singleton2() { }

	Singleton2(const Singleton2& s) = delete;
	Singleton2& operator=(const Singleton2& s) = delete;

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

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

特点：延迟加载，程序启动快，可以指定多个单例对象的初始化顺序

缺陷：实现较为复杂