c++系列之特殊类的设计

💗 💗 博客:小怡同学
💗 💗 个人简介:编程小萌新
💗 💗 如果博客对大家有用的话，请点赞关注再收藏

🌞

仅在堆上创建对象的类

将类的构造函数，拷贝构造私有,防止在栈上生成对象
提供静态成员函数，该静态成员函数中完成堆对象的创建，用类名：：函数的方式调用该函数
目的是返回一个在堆上生成的对象

class HeapOnly
{
private:
	HeapOnly()
	{}
	HeapOnly(const HeapOnly& h) = delete;
	HeapOnly& operator=(const HeapOnly&) = delete;//防止拷贝
public:
	static HeapOnly* GetHeapOnly()
	{
		return new HeapOnly;
	}
};

仅在栈上创建对象的类

将类的构造函数私有防止在堆上生成对象
提供静态成员函数，该静态成员函数中完成堆对象的创建，用类名：：函数的方式调用该函数
目的是返回一个在栈上生成的对象
注意：不能拷贝函数=delete因为该静态函数返回的是值拷贝需要调用拷贝构造

class StackOnly
{
private:
	StackOnly()
	{}
	void* operator new(size_t size) = delete;
	
	
public:
//不能引用是因为st出栈后会被销毁
	static StackOnly GetStackOnly()
	{
		StackOnly st;
		return st;
	
	}
};

设计不能被继承的类

将基类用final关键字标志

 class test final
{
private:
	test(const test& v) = delete;
	test& operator=(const test& v) = delete;
public:
	int _a;
	test(int a)
		:_a(a)
	{}
};

设计单例对象

单例模式

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
//单例模式有两种情况
饿汉模式：
是说不管你将来用不用，程序启动时就创建一个唯一的实例对象
懒汉模式：
例对象构造十分耗时或者占用很多资源所以
懒汉模式延迟加载的方式更好
//单例模式的特定就是 构造函数私有 调用静态成员函数返回静态或者全局的变量/指针

饿汉模式

namespace hunry
{
	class Single
	{
	private:
		static Single tmp;
		Single()
		{}
	public:
		static Single GetInstance()
		{
			return tmp;
		}
	};
}

懒汉模式

namespace lazy
{
	class Single
	{
	private:
		static Single* tmp;
		Single()
		{}
	public:
	//因为需要显示调用析构函数所以设置这个类
		static Single* GetInstance()
		{
			if (tmp == nullptr)
				return tmp = new Single;
			else
				return tmp;
		}
		static Single Destory()
		{
			if (tmp == nullptr)
			{
				delete tmp;
				tmp = nullptr;
			}
		}
	};
	 Single* Single::tmp = nullptr;
}