探索设计模式——单例模式详解

        前言：设计模式的作用主要是为了——利用设计方式的重用来自动地提高代码的重新利用、提高代码的灵活性、节省时间， 提高开发效率、低耦合，封装特性显著， 接口预留有利于扩展。

        设计模式的种类有很多种，本篇内容主要讲解其中的单例模式。

什么是单例模式

        单例模式是创建型模式的一种。顾名思义， 单例模式就是全局只有一个实例化对象。该种模式可以保证一个类不能创建新的对象。 也就是不能直接定义和new。      单例模式保证了全局只有唯一一份实例化对象， 而且它能够自行实例化并且向整个系统提供这个实例。这种类，提供了全局的方法， 叫做单例类， 而这种设计方法， 叫做单例模式。

        同时， 单例模式又分为饿汉模式和懒汉模式两种。下面为他们两个的特性:

• 饿汉模式：程序开始前先将唯一实例创建出来。
• 懒汉模式：第一次使用时再将唯一实例创建出来。

          两者的优缺点：

  • 饿汉模式：优点是设计简单。但缺点是可能导致程序的启动较慢，不能延迟加载。并且当有多个单例对象的时候， 哪个对象先生成不确定。
  • 懒汉模式：优点是解决了程序启动慢的问题， 延迟了加载。 并且当有多个单例对象的时候， 可以创建的顺序。 但缺点是设计比较复杂， 同时存在线程安全问题， 解决线程安全问题会导致程序的性能降低。

            综上， 我们要知道单例模式的三个主要特性： 

    • 一个类里面只能有一份实例。
    • 这个类能够自行创建这个实例。
    • 必须向整个系统提供这个实例。

      为什么要有单例模式：

              在我们的电脑中其实有许多程序我们都只能打开一次， 其实这就是应用了单例模式。 比如当我们打开“设置”， 如果你多次点击“设置”。 他也只能打开一个设置窗口（如果你打开了多个，并且不是你本人自己修改了操作系统。那么请给你的电脑杀一下毒）。 我们不妨想一下， 如果我们能够打开多个设置， 那么是不是就显得有点多余， 因为我们只使用一个设置窗口就可以，不需要使用多个。开启多个设置窗口不仅会占用系统上的资源，并且， 如果我们能够打开多个设置窗口。 那么我们在这个窗口设置成这个样子， 在那个窗口设置成那个样子。 最终， 设置的结果是用哪个窗口的呢？所以， 这都是问题。 而单例模式就是为了解决这些的问题。 

      

      代码实现

            饿汉模式

              饿汉模式就是在程序启动之前就自行创建好了这个实例。 这一点我们可以通过静态成员变量来实现， 同时为了保证类的封装性， 我们将这个静态成员变量私有化：

      	class Only_Instance 
      	{
      	private: static Only_Instance _inst;        //私有化唯一实例
      	};
          Only_Instance Only_Instance::_inst;         //静态成员变量的定义。

              然后为了保证全局只有唯一一份实例， 我们需要私有化该类的构造函数， 这样就能保证类外不能随意创建对象。 

      	class Only_Instance 
      	{
      	private: static Only_Instance _inst;        //类唯一实例
      	//私有化构造函数
      	private: Only_Instance() {};                
      	private: Only_Instance(const Only_Instance&) = delete;       
      	};
      	Only_Instance Only_Instance::_inst;         //静态成员变量定义

               如此一来， 我们就能保证：该类只有唯一一份实例化对象。 并且能够在程序启动之前自行创建一份实例。

              那么就要解决访问这个唯一一份实例的问题， 我们如何对它进行访问？ 我们可以通过一个共有的方法来访问它， 并且因为我们没有实例化对象调用成员函数以及方法的全局性， 所以这个方法必须是静态的， 全局的：

      	class Only_Instance 
      	{
      	private: static Only_Instance _inst;        //类唯一实例
      	//私有化构造函数
      	private: Only_Instance() {};                
      	private: Only_Instance(const Only_Instance&) = delete;       
      	public: 
      		static Only_Instance* getInstance()   //公有的全局方法
      		{
      			return &_inst;
      		}
      	};
      	Only_Instance Only_Instance::_inst;         //静态成员变量定义

      这样，我们就设计出了一个简单的饿汉模式。但是饿汉的不能延迟加载， 启动慢是一个问题。 为了解决， 这个问题。 我们这里看一下另一个设计模式——懒汉模式

              懒汉模式

      懒汉模式是在第一次使用的时候自行生成实例。 能够延迟加载， 解决了启动慢的问题。

      懒汉模式同样需要私有化构造函数， 不能在外部创建实例化对象:

      	class Only_Instance 
      	{
      		//构造函数
      	private:Only_Instance() {};
      	private:Only_Instance(const Only_Instance&) = delete;
      	};

      为了能够第一次才实例化对象， 我们需要在类地内部创建对象。 那么就不能定义一个全局的单例对象， 应该定义一个全局的单例对象指针， 并且这个指针也是私有的：

      	class Only_Instance 
      	{
      		//构造函数
      	private:Only_Instance() {};
      	private:Only_Instance(const Only_Instance&) = delete;
      	private:static Only_Instance* _inst;                       //全局的对象指针。
      	};

       那么如何才能访问这个指针， 我们用到和饿汉相同的方式。 就是定义一个全局的静态方法:

      	class Only_Instance 
      	{
      		//构造函数
      	private:Only_Instance() {};
      	private:Only_Instance(const Only_Instance&) = delete;
      	private:static Only_Instance* _inst;                       //全局的对象指针。
      	public:
      		static Only_Instance* getInstance()     //访问inst
      		{
      			if (_inst == nullptr) 
      			{
      				_inst = new Only_Instance();
      			}
      			return _inst;
      		}
      	};

              这样， 就能创建一个通过受控地_inst, 随时访问我们规定的方法getInstance。

              然后， 为了能够手动的销毁这个实例， 我们还要提供一个自动释放的接口：

      		//销毁实例化对象
      		public static void DelInstance() 
      		{
      			delete _inst;
      		}

       并且，为了资源能够自动释放。 我们可以定义一个内部类成员。 当这个成员销毁的时候， 那么调用inst的析构， 即：

      	class Only_Instance 
      	{
      		//构造函数
      	private:Only_Instance() {};
      	private:Only_Instance(const Only_Instance&) = delete;
      	private:static Only_Instance* _inst;                       //全局的对象指针。
      	public:
      		static Only_Instance* getInstance()     //访问inst
      		{
      				if (_inst == nullptr)
      				{
      					_inst = new Only_Instance();
      				}
      			return _inst;
      		}
      		
      		//销毁实例化对象
      		static void DelInstance() 
      		{
      			delete _inst;
      		}
      		class auto_des
      		{
      		public:
      			~auto_des() 
      			{
      				delete _inst;
      			}
      		};
      		static auto_des _ad;
      	};
      	
      	Only_Instance::auto_des Only_Instance::_ad;

              但是， 这个懒汉模式此时有另外的问题。 当涉及多线程时，如果我们一个程序跑到了if语段， 另一个程序也跑到了if语段。 那么如果两个if语段同时执行， 那么就会造成创建多个实例对象的情况。 为了避免这种情况，这里就要用到加锁地操作。 这个由于博主知识板块不太完整， 暂时不进行详细讲解。

              想要了解地请看大佬的这篇文章：确保对象的唯一性——单例模式 （三）_青兮科技公司开发人员使用单例模式实现了负载均衡器的设计,但是在实际使用中出现-CSDN博客

      其他简单特殊类设计

      只能在堆上创建对象

              只能在堆上创建对象， 只能在堆区创建对象。 那么我们就要让这个类无法随便创建对象。 那么使用的方法就是私有化或者封掉构造函数。 即:

      class Only_Heap
      {
      public:
      	Only_Heap* CreatObj()
      	{
      		return new Only_Heap;
      	}
      	//要注意将拷贝构造禁掉
      	Only_Heap(const Only_Heap& pt) = delete;
      private:
      	//
      	Only_Heap()
      	{
      		cout