c++单例模式总结

单例可能是最常用的简单一种设计模式，实现方式多种多样

c++单例写法有懒汉式，线程安全，模板等，各种实现方式都有局限性

单例特点是只提供唯一一个类的示例，具有全局变量的特点，在任何位置可以通过接口获取到唯一示例

懒汉式 直接使用实例化对象，new一个单例对象

/*
*@author: 赵秋然
*@date:2021年4月10日
*@description: 
*/

#include<iostream>

class single {
  public:
    virtual ~single()
    {
        std::cout << "destory single" << std::endl;
    }

    single(const single&) = delete;
    single& operator=(const single&) = delete;
    static single *get_instance()
    {
        if (instance == NULL) {
            instance = new single;
        }

        return instance;
    }

  private:
    static single *instance;
    single()
    {
        std::cout << "construt single" << std::endl;
    }
};

single *single::instance = NULL;

int main(int argc, char *argv[])
{
    single *instance1 = single::get_instance();
    single *instance2 = single::get_instance();
    single *instance3 = single::get_instance();
    return 0;
}

运行显示：construt single

获取三次类的get_instance，只有一次类的构造函数被调用，表明只生成了唯一示例

但是会有一些问题：线程安全问题，多线程引发竞太条件；第一个线程在if中判断是空的，于是开始示例单例

同时第二个线程也尝试获取单例，这时候判断还是空的，于是就开始实例化两个对象；这是线程安全问题，就需要加锁

内存泄漏问题，类只负责new出对象，却没有负责delete对象，因此构造函数被调用，析构函数却没有调用，会导致内存泄漏，这里需要共享指针

改进方法：线程安全 ，内存安全的懒汉式单例（智能指针 锁）

/*
*@author: 赵秋然
*@date:2021年4月10日
*@description: g++ ab.cpp -std=c++11 -g
*/
#include<iostream>
#include<memory>//shared_ptr
#include<mutex> //mutex
class single {
  public:
    typedef std::shared_ptr<single> PTR;

    virtual ~single()
    {
        std::cout << "destory single" << std::endl;
    }

    single(const single&) = delete;
    single& operator=(const single&) = delete;
    static PTR get_instance()
    {
        if (instance == NULL) {
            std::lock_guard<std::mutex> lk(i_mutex);
            if (instance == NULL) {
                instance = std::shared_ptr<single>(new single);
            }
        }

        return instance;
    }

  private:
    single()
    {
        std::cout << "construt single" << std::endl;
    }

    static PTR instance;
    static std::mutex i_mutex;
};

single::PTR single::instance = NULL;
std::mutex single::i_mutex;

int main(int argc, char *argv[])
{
    single::PTR instance1 = single::get_instance();
    single::PTR instance2 = single::get_instance();
    single::PTR instance3 = single::get_instance();
    return 0;
}

显示：

construt single
destory single

基于shared_ptr,当对象管理析构的时候，new出来的对象也会被delete掉，避免内存泄漏

加了锁，使用互斥量达到线程安全，这里使用了两个if判断语句为双检锁，好处判断指针为空的时候加锁，避免每次调用 的方法都加锁，锁的开销资源占用较大，实际在默写平台下，双检锁会失效

推荐懒汉式单例 magic  static  局部静态变量达到线程安全

/*
*@author: 赵秋然
*@date:2021年4月10日
*@description: 
*/

#include<iostream>

class single {
  public:
    virtual ~single()
    {
        std::cout << "destory single" << std::endl;
    }

    single(const single&) = delete;
    single& operator=(const single&) = delete;

    static single& get_instance()
    {
        static single instance;
        return instance;
    }


  private:
    single()
    {
        std::cout << "construt single" << std::endl;
    }
};


int main(int argc, char *argv[])
{
    single& instance1 = single::get_instance();
    single& instance2 = single::get_instance();
    single& instance3 = single::get_instance();
    return 0;
}

结果：

construt single
destory single

1.通过局部静态变量的特性保证了线程安全 c++ 11 gcc>4.3 vs2015支持这个特性

2.不需要使用共享指针，代码简洁

3.在使用的时候需要声明单例的引用才能获取对象

网上有人的实现是返回指针不是应用，

static single *get_instance()
{
    static single instance;
    return &single;
}

这种返回指针不是引用,这种无法避免用户使用 delete instance 导致被提前销毁

后续不足再补充