特殊类设计

特殊类设计

1.设计一个只能在堆上创建对象的类

class HeapOnly
{
public:
	HeapOnly(const HeapOnly&) = delete;
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly() {}
};

2.设计一个只能在栈上创建对象的类

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

3.设计一个类不能被拷贝

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

4.设计一个类不能被继承

class A final
{
	//...
};

5.设计一个类只能创建一个对象（单例模式）

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

饿汉模式

不管将来用不用，程序启动时就创建一个唯一的实例对象。

class singleton
{
public:
	static singleton* GerInstance()
	{
		return &m_instance;
	}
	singleton(const singleton&) = delete;
	singleton& operator=(const singleton&) = delete;
private:
    singleton(){}
	static singleton m_instance;
};
//在程序入口之前就完成单例对象的初始化
singleton singleton::m_instance;

懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件， 初始化网络连接，读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

class singleton
{
public:
	static singleton* GerInstance()
	{
		if (m_instance == nullptr)
		{
			m_mtx.lock();
			if (m_instance == nullptr)
			{
				m_instance = new singleton();
			}
			m_mtx.unlock();
		}
		return m_instance;
	}

	//实现一个内嵌垃圾回收类
	class CGarbo
	{
	public:
		~CGarbo()
		{
			if (singleton::m_instance)
				delete singleton::m_instance;
		}
	};

	static CGarbo Garbo;

	singleton(const singleton&) = delete;
	singleton& operator=(const singleton&) = delete;
private:
	singleton() {}
	static singleton* m_instance;
	static mutex m_mtx;
};
singleton* singleton::m_instance = nullptr;
mutex singleton::m_mtx;
singleton::CGarbo Garbo;