【C++高阶(八)】单例模式&特殊类的设计

💓博主CSDN主页:杭电码农-NEO💓

⏩专栏分类:C++从入门到精通⏪

🚚代码仓库:NEO的学习日记🚚

🌹关注我🫵带你学习C++

  🔝🔝

单例模式

• 1. 前言
• 2. 设计一个不能被拷贝/继承的类
• 3. 只能在堆上创建对象的类
• 4. 只能在栈上创建对象的类
• 5. 只能实例化一个对象的类的介绍
• 6. 饿汉模式的具体实现
• 7. 懒汉模式的具体实现
• 8. 总结以及拓展

  1. 前言

  在实际场景中,总会遇见一些特殊情况,

  比如设计一个类,只能在堆上开辟空间,

  亦或者是设计一个类只能实例化一个对象

  在实际需求的场景下,来学习这节实用课

  本章重点:

  本篇文章着重讲解如何设计一些特殊

  的类,包括不能被拷贝,只能在栈/堆上

  创建对象以及此类只能实例化一个对象,

  这也就是题目中的单例模式,单例模式又

  包含饿汉和懒汉模式,文章都是干货

  请同学们耐心学习!

  ---

  2. 设计一个不能被拷贝/继承的类

  1. 设计一个不能被拷贝的类

  C++11中引入的关键字delete

  就能很好的解决这个问题,并且

  不仅仅要禁用拷贝,还有赋值!

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

  在C+98中,也有方法能够解决,

  那就是显示将拷贝构造函数和

  赋值运算符重载函数私有化!

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

  1. 设计一个不能被继承的类

  使用关键字final就能解决问题

  class A  final
  {
      // ....
  };
  

  在C++98中,将构造函数私有化也能

  达到目的,因为子类的构造会调用基类

  的构造,如果私有了基类的构造就会报错!

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

  ---

  3. 只能在堆上创建对象的类

  只能在堆上创建对象的含义就是

  必须使用new来创建对象.

  本篇文章是实用性的,就直接讲方法了:

  1. 将析构函数私有化

  将析构函数私有化后,由于对象析构时并不能调用到析构函数,所以不管是在堆上还是栈上创建对象都会报错!但是我们可以特殊处理,在共有域定义一个函数,此函数显示调用析构!

  //思路一,封析构函数
  class HeapOnly
  {
  public:
  	void destory()
  	{
  		delete this;
  	}
  private:
  	~HeapOnly()
  	{
  		cout
  public:
  	static HeapOnly* CreateObject(int x = 0)
  	{
  		return new HeapOnly(x);
  	}
  private:
  	HeapOnly(int x = 0):_x(x)
  	{}
  	int _x;
  };
  
  public:
  	static StackOnly CreateObj()
  	{
  		return StackOnly();
  	}
  // 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
  // StackOnly obj = StackOnly::CreateObj();
  // StackOnly* ptr3 = new StackOnly(obj);
  	void* operator new(size_t size) = delete;
  	void operator delete(void* p) = delete;
  private:
  	StackOnly()  
  		:_a(0)
  	{}
  	private:
  	int _a;
  };
  
  public:
  	static Singleton* GetInstance()
  	{
  		return _ins;
  	}
  private:
  	//限制类外随意创建对象
  	Singleton(const Singleton& s) = delete;
  	Singleton& operator=(const Singleton& s) = delete;
  	Singleton()
  	{}
  private:
  	static Singleton* _ins;
  };
  Singleton* Singleton::_ins = new Singleton;
  
  public:
  	static Singleton* GetInstance()
  	{
  		if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
  		{
  			imtx.lock();
  			if (_ins == nullptr)//第一次调用才创建实例!
  			{
  				_ins = new Singleton;
  			}
  			imtx.unlock();
  		}
  		
  		return _ins;
  	}
  	void DelInstance()
  	{
  		imtx.lock();
  		if (_ins != nullptr)
  		{
  			cout }
  private:
  	static Singleton* _ins;
  	static mutex imtx;
  };
  Singleton* Singleton::_ins = nullptr;
  mutex Singleton::imtx;