第62课单例类模板

最新推荐文章于 2024-03-11 13:54:13 发布

码农小李。x17355150737

最新推荐文章于 2024-03-11 13:54:13 发布

阅读量283

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/qq_35604488/article/details/79193026

版权

C++ 专栏收录该内容

42 篇文章 2 订阅

订阅专栏

1、单例需求的提出

1.1、在架构设计时，某些类在整个系统生命期中 最多只能有一个对象 存在(Single Instance)

1.2、问题：如何定义一个类，使得这个类最多只能创建一个对象

C++中解决方案：1、将构造函数，拷贝构造函数，赋值操作符设置为private的。2、创建一个private的该类的static指针，并且创建一个获得目标类指针的static方法（只能获取堆空间创建对象的指针）。

2、单例模式

2.1、要控制类的对象数目，必须 对外隐藏构造函数

2.2、思路

2.2.1、将构造函数的访问属性设置为 private

2.2.2、定义instance，并初始化为NULL

2.2.3、提供静态函数getInstance来返回单例实例，并判断当instance的值为空时，并创建对象，并保存在instance指针中，非空值时直接返回instance标记的对象。

 
  /*********         单例模式初探       **********/ 
 
  #include <iostream> 
 
  #include <string> 
 
  using namespace std; 
 
  class SObject 
 
  { 
 
      //静态c_instance, 用于保存实例对象的指针 
 
      static SObject* c_instance; 
 
      //隐藏构造函数，拷贝构造，赋值操作符 
 
      SObject(const SObject&) 
 
      { 
 
      } 
 
      SObject& operator=(const SObject&) 
 
      { 
 
      } 
 
      SObject() 
 
      { 
 
      } 
 
  public: 
 
      static SObject* GetInstance();  //声明静态成员函数 
 
      void print() 
 
      { 
 
          cout << "this = " << this << endl; 
 
      } 
 
  }; 
 
  SObject* SObject::c_instance = NULL;       //初始化静态成员变量。 
 
  SObject* SObject::GetInstance()             //定义静态成员函数。 
 
  { 
 
      if( c_instance == NULL )    //静态成员函数中只能使用静态成员变量。 
 
      { 
 
          c_instance = new SObject();  //如果为NULL，则重新申请一个类地址。 
 
      } 
 
      return c_instance; 
 
  } 
 
  int main() 
 
  { 
 
      //SObject q; 
 
      SObject* s = SObject::GetInstance(); 
 
      SObject* s1 = SObject::GetInstance(); 
 
      SObject* s2 = SObject::GetInstance(); 
 
      s->print(); 
 
      s1->print();   //打印出来的三个地址都是一样的，说明是单例 
 
      s2->print(); 
 
      return 0; 
 
  }

3、单例类的设计

3.1、存在问题

必须为每个单例类定义c_instance静态成员变量和GetInstance()静态成员函数。而这些不是类本身的职责，而且每个类都这样定义这两者也是个重复的劳动过程。

3.2、解决方案

将单例模式相关的代码抽取出来，开发单例类模板。当需要单例类时，直接使用单例类模板

//单例类模板

 
  #ifndef _SINGLETON_H_ 
 
  #define _SINGLETON_H_ 
 
  #include <iostream> 
 
  template <typename T> 
 
  class Singleton 
 
  { 
 
      static T* c_instance; 
 
  public: 
 
      static T* GetInstance(); 
 
  }; 
 
                                //将重复劳动的东西提取出来。 
 
  template <typename T> 
 
  T* Singleton<T>::c_instance = NULL; 
 
  template <typename T> 
 
  T* Singleton<T>::GetInstance()  //静态成员函数只能使用静态成员变量。 
 
  { 
 
      if(c_instance == NULL) 
 
      { 
 
          c_instance = new T();   //这个类声明为友元类可以调用SObject已被私有化的构造函数 
 
      } 
 
      return c_instance; 
 
  } 
 
  #endif

 
  #include <iostream> 
 
  #include "Singleton.h" 
 
  using namespace std; 
 
  class SObject 
 
  { 
 
      //当前类需要使用单例模式 
 
      //可以先忽略下一行代码，直接去看main中的函数，然后再回来理解 
 
      //这里为什么要将Singleton<SObject>类声明为SObject类的友元类？ 
 
      //其目的是为了让Singleton<SObject>类内部可以调用SObject的己被 
 
      //私有的构造函数 
 
      friend class Singleton<SObject>; 
 
      //要单例的类，需要将构造函数，拷贝构造函数，赋值操作符赋隐藏起来，否则外界可以随便new 
 
      SObject(const SObject&); 
 
      SObject& operator=(const SObject&); 
 
      SObject(){} 
 
      public: 
 
      void print() 
 
      { 
 
          cout << "this = " << this << endl; 
 
      } 
 
  }; 
 
  int main() 
 
  { 
 
       //Singleton<SObject>虽然是通过类模板产生的，但其实是一个实实在在 
 
      //存在的新的类，然后通过这个类，去创建SObject类的一个实例，由于 
 
      //Singleton<SObject>类内部的GetInstance控制了SObject对象的实例 
 
      //的产生。因此，每个调用getInstance就只能获得SObject的一个对象。 
 
      //本质上，单例类模板是通过模板去创建一个类，然后利用这个类来控制另一个 
 
      //类对象的创建！ 
 
      SObject* s = Singleton<SObject>::GetInstance(); 
 
      SObject* s1 = Singleton<SObject>::GetInstance(); 
 
      SObject* s2 = Singleton<SObject>::GetInstance(); 
 
      s->print(); 
 
      s1->print(); 
 
      s2->print(); 
 
      return 0; 
 
  }

//boost库中的单例类模板

 
  #ifndef _SINGLETON_H_ 
 
  #define _SINGLETON_H_ 
 
  //boost库的单例类模板（饿汉式，多线程安全的单例模板类） 
 
  template <typename T> 
 
  struct singleton_default 
 
  { 
 
  private: 
 
      singleton_default(); //模板类的构造函数私有化 
 
      //内部类 
 
      struct object_creator 
 
      { 
 
           object_creator(){singleton_default<T>::instance();} 
 
           inline void do_nothing()const{} 
 
      }; 
 
      static object_creator create_object; //声明：内部类的静态实例 
 
  public: 
 
      typedef T object_type; 
 
      static object_type& instance() 
 
      { 
 
          static object_type obj; //要单例的类实例，放在静态区里 
 
          //空函数，据说这与模板类的编译有关，可以确保内部类运行 
 
          //该函数时，其构造函数(调用了{singleton_default<T>::instance()) 
 
          //被执行 
 
          create_object.do_nothing(); 
 
          return obj; 
 
      } 
 
  }; 
 
  template<typename T> 
 
  typename singleton_default<T>::object_creator   //typename==class，内部类类型 
 
  singleton_default<T>::create_object;    //定义内部类的静态实例 
 
  #define INSTANCE(class_name) singleton_default<class_name>::instance(); 
 
  #endif  //_SINGLETON_H_

 
  #include <iostream> 
 
  #include "Singleton.h" 
 
  using namespace std; 
 
  class Test 
 
  { 
 
  private: 
 
      //构造函数私有化 
 
      Test(){} 
 
      Test(const Test&); 
 
      Test& operator=(const Test&); 
 
      friend class singleton_default<Test>;//在这个类中使用Test类的构造函数 
 
  public: 
 
      void print() 
 
      { 
 
          cout << "test::this " << this <<endl; 
 
      } 
 
  }; 
 
  int main() 
 
  { 
 
      Test& t= INSTANCE(Test); 
 
      t.print(); 
 
      Test& t2=INSTANCE(Test); 
 
      t2.print(); 
 
      return 0; 
 
  }