【C++】特殊类 | 单例模式

发布时间:2024年01月20日

在某些特殊场景,我们可能会希望一个类只能创建在堆上、不能被拷贝、不能被继承。

又或者我们希望一个类在main函数启动前就已经被实例化出来,并且我们不能再创建,这里就涉及到特殊类和单例模式。

阅读本文,将对你理解特殊类、单例模式有极大的帮助。

特殊类

一、设计一个不能被拷贝的类

拷贝出现的场景只有拷贝构造和赋值。因此不能被拷贝的类必须禁用拷贝构造和赋值操作

C++98中:

  • 将拷贝构造和赋值运算符重载只声明不实现,并且声明为私有

1、设计为私有:防止用户在类外为函数定义

2、只声明不实现,会发生链接错误。不能完成编译。

C++11

delete关键字 删除默认成员函数(推荐写法)

//请设计一个类,该类不能发生拷贝
class copyban
{
public:
	copyban(const copyban&) = delete;
	copyban& operator=(const copyban&) = delete;

private:

};

这样就禁用拷贝构造和赋值运算符的生成


二、设计一个在堆上的类

有俩种实现:

1、析构函数私有化

2、构造函数私有化


1)析构私有

析构私有化,可行的原因:

C++是一个静态绑定的语言。在编译过程中,所有的非虚函数调用必须完成分析,即使是虚函数,也要检查可访问性。如果要在栈上生成对象,对象会自动调用构造和析构,也就是构造和析构必须可访问。否则编译错误。但是在堆上创建的对象,由于释放可以通过delete,所以在堆上的对象不一定要有析构函数。

class heaponly
{
public:
	heaponly()
	{
		cout << "heaponly()" << endl;
	}
	void destory()
	{
		delete this;
	}
private:
	~heaponly()
	{
		cout << "~heaponly()" << endl;
	}

};
int main()
{
	heaponly *hp1 = new heaponly;
	
	heaponly hp(*hp1);
	return 0;
}

小细节:

????????由于析构的私有化,delete调不动析构函数,因此需要自定的destory函数完成清理工作


2)构造私有

我们指定生成的对象在堆上

构造函数私有,不能通过普通定义来创建对象

禁用拷贝构造,防止用堆上的对象去构造栈上的对象

提供静态成员函数,用来创建堆上的对象

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

	HeapOnly(const HeapOnly& hp) = delete;
private:
	HeapOnly(){}
	
};

int main()
{
	HeapOnly*hp= HeapOnly::CreateObj();
	HeapOnly hp1(*hp);
	return 0;

}

注意点:

  • 由于不能直接创建,也不能new 产生。需要通过静态函数调用产生对象。因为全局函数不属于某个类,在一开始就被实例化。而将静态成员函数放在类中,就可以指定作用域。
  • 静态成员new的返回值是指针!拷贝构造被禁用了!


三、设计一个在栈上的类

1、构造私有

2、构造公有


1)构造函数私有化

私有构造函数,就不能在类外调用构造函数创建对象。因此需要类中提供静态的成员函数来提供对象的创建。

不能防止拷贝构造。new出来的对象可以赋值给变量。

如果禁用拷贝构造,则在对象创建后,返回值无法传递。

//请设计一个类,只能在栈上创建对象
//构造函数私有

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

int main()
{
	StackOnly sn = StackOnly::CreatObj();
	StackOnly *sl = new StackOnly(sn);
	return 0;
}

因此第一种方法并不能完全实现在栈上创建

2)构造公有

把构造函数公有,operator new和delete禁掉?

class StackOnly
{
public:
	StackOnly() {};

private:
	void* operator new(size_t size) = delete;

	void operator delete(void* p) = delete;
};

int main()
{
	StackOnly sn;
	//StackOnly* sl = new StackOnly;
	return 0;
}

这样子屏蔽了new的创建对象,但是依旧不发避免静态区创建的对象。


单例模式

设计模式就是反复被人们使用,多人知晓的总结。

单例模式:一个类只能创建一次,该模式可以提供一个实例,并且提供全局的访问。


单例模式分为:
饿汉模式和懒汉模式

1)饿汉模式

提前创建好对象,在main函数的启动时。

注意点:

  • 需要提前创建好对象,则在类中创建对象放为全局。
  • 要实现单例,则需要将构造函数私有化,提供静态的成员函数,获取对象的指针。
  • 防止拷贝构造,禁掉拷贝构造和赋值。
  • 在类外提供类的静态对象获取单例。

class sigleton
{
public:
	static sigleton* GetInstance()
	{
		return &m_instance;
	}

private:
	sigleton();
	sigleton(const sigleton&) = delete;

	sigleton& operator=(const sigleton&) = delete;
	static sigleton m_instance;
	int _a = 0;
};

sigleton sigleton::m_instance;

int main()
{
	sigleton a();
	return 0;
}

饿汉模式的优点:
实现简单

缺点:
启动慢,在程序启动时,会创建所有的单例对象,占用大量的时间。如果有多个单例,实例化的顺序无法确定。


2)懒汉模式

解决了懒汉模式启动慢。耗费大量资源。懒汉模式是在调用时才会创建。

实现方法:
以饿汉模式为基础,懒汉模式类中的对象是指针,静态成员函数的返回值为一个new的指针

因此只有在调用时才会创建对象

资源是不需要释放的,因为在进程结束时,会自动回收。

如果需要做一些动作,比如持久化。可以利用gc的static托管。

class InfoMgr
{
public:
	static InfoMgr* GetInstance()
	{
		if (_inst == nullptr)
		{
			_inst = new InfoMgr;
		}
		return _inst;
	}
	static void DelInstance()
	{
		if (_inst)
		{
			delete _inst;
			_inst = nullptr;
		}
	}

private:
	InfoMgr();
	InfoMgr(const InfoMgr&) = delete;
	InfoMgr& operator =(const InfoMgr&) = delete;
	int _n = 0;
	static InfoMgr* _inst;

	class gc
	{
		public:
			~gc()
			{
				DelInstance();
			}
	};
	static gc _gc;
};

InfoMgr* InfoMgr::_inst = nullptr;
InfoMgr::gc InfoMgr::_gc;

优点:
启动快,由调动时才创建对象。可以确定顺序。

缺点:

实现复杂,多线程问题,加锁等问题。


总结

本文共介绍了几种特殊类的实现

防止拷贝的类:

????C++98中私有,只声明不实现拷贝构造、赋值运算符。C++11 delete关键字删除拷贝构造和赋值

在堆上创建的类:

? ? ? ? 1)析构私有,需要实现destory。

????????2)构造私有,静态成员函数返回new对象指针 delete拷贝构造。

在栈上创建:
? ? ? ? 推荐构造公有,禁用operator new 和operator delete 缺点是静态区仍然可以创建

单例模式:
在类中创建静态成员对象,饿汉是对象,懒汉是对象指针

饿汉是在程序启动时就创建,懒汉是在首次调用时为空进入new创建对象。

文章来源:https://blog.csdn.net/m0_73299809/article/details/135708848
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。