cpp11-singleton

  • 懒汉式

    • 用的时候才初始化

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
       class CSingleton  
      {
      public:
      static CSingleton* GetInstance()
      {
      if ( m_pInstance == NULL ) //非线程安全
      m_pInstance = new CSingleton();
      return m_pInstance;
      }
      private:
      CSingleton(){};
      static CSingleton * m_pInstance;
      };
  • 懒汉式,内存泄漏的改进

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
           class CSingleton    
      {
      private:
      CSingleton()
      {
      }
      static CSingleton *m_pInstance;
      class CGarbo
      {
      public:
      ~CGarbo()
      {
      if(CSingleton::m_pInstance)
      delete CSingleton::m_pInstance;
      }
      };
      static CGarbo Garbo;//定义一个静态成员变量,程序结束时,系统会自动调用它的析构函数
      public:
      static CSingleton * GetInstance()
      {
      if(m_pInstance == NULL)
      m_pInstance = new CSingleton();
      return m_pInstance;
      }
      };
      /*
      1.在单例类内部定义专有的嵌套类。
      2.在单例类内定义私有的专门用于释放的静态成员。
      3.利用程序在结束时析构全局变量的特性,选择最终的释放时机。
      */
  • 懒汉式,线程安全的改进,加锁

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class CSingleton
      {
      private:
      CSingleton() //构造函数是私有的
      {
      }
      static CSingleton *m_pInstance;
      mutex mtx;
      public:
      static CSingleton * GetInstance()
      {
      mtx.lock();//加锁
      if (m_pInstance == NULL) //判断是否第一次调用
      m_pInstance = new CSingleton();
      mtx.unlock();//释放锁
      return m_pInstance;
      }
      };
  • 饿汉式

    • 饿汉式线程安全

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
       class CSingleton    
      {
      private:
      CSingleton()
      {
      }
      public:
      static CSingleton * GetInstance()
      {
      static CSingleton instance;
      return &instance;
      }
      };
  • 关于单例模式中的拷贝构造函数

    • 尽量加,否则可以调用编译器的默认拷贝构造生成另一个对象

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      class B {
      private:
      B() {}
      //B(const B& b) {}
      public:
      static B& get_instance()
      {
      static B b;
      return b;
      }
      void func()
      {
      cout << "B::func"<< endl;
      }
      };
      B::get_instance().func();
      B b1 = B::get_instance();

      printf("&b1 %p\n",&b1);
      B b2(b1);

      printf("&b2 %p\n", &b2);
      /*
      B::func
      &b1 0000007E4ABCFB04
      &b2 0000007E4ABCFB24
      */
文章目录