C++ 单例模式

Posted 2021-10-08 菜菜变大佬

@toc

1.什么是单例模式

• 单例模式，是设计模式中的一种（设计模式是前辈们总结经验设计的一些贴合众多应用场景的设计思想与结构），对于单例模式来说，它保证了一个工程中，某种资源（单例管理的）有且只有一份
• 就我个人观点，在日常工程中，单例一般做对数据总处理的最外层 system管理类

  2.单例的基本设计思想

  思想1：单例模式保证独有资源一份，意味着不允许额外的构造，拷贝构造，和赋值相关的隐式构造
  设计1：构造析构私有化 ， 拷贝构造禁止掉，赋值构造禁止掉
  思想2： 提供全局访问的外接点
  设计2：利用static 关键词， 设置静态成员变量，相对应的静态成员函数
  思想3：在具有延迟加载思想的“懒汉模式中”，存在一种实现方式是“局部静态变量”，可以保证实现线程安全的单例模式

  3.饿汉模式

  饿汉模式：提前准备好，需要的时候直接用
  即：对于某个工程对 此份独有资源的需求，需要提前准备好，基于主main函数之前准备好资源

• 饿汉模式资源加载 编译过程中

  饿汉的实现

  ```c++
  class Singleton{
  public:
  static Singleton* GetInstance()
  {
  return &s;
  }
  public:
  void print(){
  cout << "hello!" << endl;
  }

private:
Singleton(){};
~Singleton(){};
Singleton(const Singleton& s) = delete;
Singleton& operator=(Singleton const& s) = delete;
static Singleton s;
};
Singleton Singleton:: s;

## 4.懒汉模式
懒汉模式：等到需要了，我再去创建一份
即：我在工程中第一次需要使用 此份独有资源，那么我就去创建并且开始使用，当然，后续再次使用则不需要重复创建
* 懒汉模式资源加载在 运行时
### （1）最简单懒汉模式（单线程）
```c++
 class SingLetonL{
 public:
     void print(){
         cout << "i am a cute baby!" << endl;
     }
     static SingLetonL* getInstance()
     {
             if (s == NULL)
             {
                s = new SingLetonL();
             }
         return s;
     }
 private:
     //构造私有;
     //拷贝构造delete  + ‘ =’ delete
     SingLetonL(){
         cout << " construction" << endl;
     };
     ~SingLetonL(){
         //if (s) delete s;
         cout << " delete" << endl;
     };
     SingLetonL(const SingLetonL& s) = delete;
     SingLetonL& operator=(SingLetonL const& s) = delete;
 private:
     static SingLetonL* s;
 };
 SingLetonL* SingLetonL::s;

（2）安全的懒汉模式

1）内置类执行内存释的思想

```c++
class SingLetonL{
public:
void print(){
cout << "i am a cute baby!" << endl;
}
static SingLetonL getInstance()
{
if (s == NULL)
{
Lock.lock();
if (s == NULL)
{
s = new SingLetonL();
}
Lock.unlock();
}
return s;
}
private:
//内置类承担析构
class Deletor{
public:
~Deletor(){
if (SingLetonL::getInstance != NULL)
delete SingLetonL::s;
}
static Deletor deletor;
};
private:
//构造私有;
//拷贝构造delete + ‘ =’ delete
SingLetonL(){
cout << " construction" << endl;
};
~SingLetonL(){
//if (s) delete s;
cout << " delete" << endl;
};
SingLetonL(const SingLetonL& s) = delete;
SingLetonL& operator=(SingLetonL const& s) = delete;
private:
static SingLetonL s;
static mutex Lock;
};
SingLetonL* SingLetonL::s;
mutex SingLetonL::Lock;

注：这里内置Deletor deletor 不能没有，是通过他的生命周期去调用 Deletor的析构的；
#### 2）C++11后支持的，有意思的优雅的局部静态变量思想的懒汉
```c++
class SingLetonL{
 public:
     void print(){
         cout << "i am a cute baby!" << endl;
     }

     static SingLetonL* getInstance()
     {
         static SingLetonL* s = new SingLetonL();
         return s;
     }
 private:
     //内置类承担析构
     class Deletor{
     public:
         ~Deletor(){
             if (SingLetonL::getInstance != NULL)
                 delete SingLetonL::s;
         }
          static Deletor deletor;
     };
 private:
     //构造私有;
     //拷贝构造delete  + ‘ =’ delete
     SingLetonL(){
         cout << " construction" << endl;
     };
     ~SingLetonL(){
         //if (s) delete s;
         cout << " delete" << endl;
     };
     SingLetonL(const SingLetonL& s) = delete;
     SingLetonL& operator=(SingLetonL const& s) = delete;
 private:
     static SingLetonL* s;
     static mutex Lock;
 };
 SingLetonL* SingLetonL::s;
 mutex SingLetonL::Lock;

欢迎大家批评指正!