单例模式

考察内容：

  • 懒汉
  • 线程安全
  • 资源释放

为何静态成员函数可调用ctor? 静态成员函数和成员函数的区别在于是否有this参数，但由于ctor不存在this参数，故静态成员函数可调用

  1. //基础版本
  2. class Singleton{
  3. protected:
  4.     Singleton() = default;
  5.     ~Singleton() = default;
  6. public:
  7.     static Singleton* get_instance(){
  8.         if(_instance==nullptr)
  9.             _instance=new Singleton();
  10.         return _instance;
  11.     }
  13.     Singleton(const Singleton& rhs)=delete;
  14.     Singleton& operator=(const Singleton&) = delete;
  15. private:
  16.     static Singleton* _instance;
  18. }
  19. //定义
  20. Singleton* Singleton::_instance=nullptr;
  22. //线程安全资源安全版本
  23. class Singleton {
  24.     using safe_ptr = std::shared_ptr<Singleton>;
  25. protected:
  26.     Singleton() = default;
  27.     ~Singleton() = default;
  28. public:
  29.     static safe_ptr get_instance() {
  30.         if (_instance == nullptr) {
  31.             std::unique_lock<std::mutex> lk(_mtx);
  32.             if (_instance == nullptr) {
  33.                 //防止当一个进程退出后，释放锁，另一个进程也在等待锁拿到后进入，而多创建一个实例
  34.                 _instance.reset(new Singleton());
  35.             }
  36.         }
  37.         return _instance;
  38.     }
  40.     Singleton(const Singleton&) = delete;
  41.     Singleton& operator=(const Singleton&) = delete;
  42. private:
  43.     static safe_ptr _instance;
  44.     static std::mutex _mtx;
  45. };
  47. std::shared_ptr<Singleton> Singleton::_instance = nullptr;
  48. std::mutex Singleton::_mtx;
  51. //线程安全资源安全版本2
  52. class Singleton {
  53.     using safe_ptr = std::shared_ptr<Singleton>;
  54. protected:
  55.     Singleton() = default;
  56.     ~Singleton() = default;
  57. public:
  58.     static safe_ptr get_instance() {
  59.         std::call_once(_flag, []()
  60.             {
  61.                 _instance.reset(new Singleton());
  62.             });
  63.         return _instance;
  64.     }
  66.     Singleton(const Singleton&) = delete;
  67.     Singleton& operator=(const Singleton&) = delete;
  68. private:
  69.     static safe_ptr _instance;
  70.     static std::once_flag _flag;
  71. };
  72. std::shared_ptr<Singleton> Singleton::_instance = nullptr;
  73. std::once_flag Singleton::_flag;
  76. //模板版本
  77. template<class Derived>
  78. class Singleton{
  79. public:
  80.     template<class ...Args>
  81.     static Derived& get_Instance(const Args& ...args);
  82. protected:
  83.     Singleton() =default;
  84.     ~Singleton() =default;
  85. private:
  86.     static std::shared_ptr<Derived> _Instance;
  87.     static std::once_flag _flag;
  88. }
  91. template<class Derived>
  92. template<class ...Args>
  93. static Derived& get_Instance(const Args& ...args){
  94.     std::call_once(_flag,[](auto ...args){
  95.         _Instance.reset(new Derived(args...))
  96.     ,args...});
  97.     return *_Instance;
  98. }
  100. template<class Derived>
  101. std::shared_ptr<Derived> Singleton<Derived>::_Instance = nullptr;
  102. template<class Derived>
  103. std::once_flag Singleton<Derived>::_flag;
  106. class A:public Singleton<A>
  107. {
  108.     friend class Singleton<derivedA>;
  109. private:
  110.     int val;
  111.     derived(int v):
  112.         val(v){}
  113. public:
  114.     constexpr
  115.     int get_val() const noexcept {    return val; }
  117. }