GoF设计模式-Singleton(单例)

局部静态变量

在C++11后，这种方式简单易用，线程安全

class Singleton
{
    Singleton()=default;
    Singleton(Singleton&) = delete;
    Singleton(Singleton&&) = delete;
    Singleton& operator=(Singleton&) = delete;
    Singleton& operator=(Singleton&&) = delete;
public:
    virtual ~Singleton() {}
    static Singleton& Instance()
    {
        static Singleton instance;
        return instance;
    }
};
int main()
{
    auto& ins = Singleton::Instance();
    return 0;
}

懒汉式(延迟加载)

延迟加载为了线程安全需要线程锁

#include <mutex>

class Singleton final
{
    inline static Singleton* instance_ = nullptr;
    inline static std::mutex mtx_;
    Singleton()=default;
    Singleton(Singleton&)=delete;
    Singleton(Singleton&&)=delete;
    Singleton& operator=(Singleton&)=delete;
    Singleton& operator=(Singleton&&)=delete;
    // 禁用外部delete;进程退出时会自动回收内存
    ~Singleton() {}
public:
    static Singleton* Instance()
    {
        std::lock_guard<std::mutex> lock(mtx_);
        if(!instance_) instance_ = new Singleton();
        return instance_;
    }

};
int main()
{
    auto ins = Singleton::Instance();
    return 0;
}

饿汉式(提前加载)

#include <cassert>

class Singleton final
{
    Singleton()=default;
    Singleton(Singleton&)=delete;
    Singleton(Singleton&&)=delete;
    Singleton& operator=(Singleton&)=delete;
    Singleton& operator=(Singleton&&)=delete;
    static Singleton* instance_;
public:
    static Singleton* Instance() {
        return instance_;
    }
};
Singleton* Singleton::instance_ = new Singleton();

int main()
{
    auto ins1 = Singleton::Instance();
    auto ins2 = Singleton::Instance();
    assert(ins1 == ins2);
    return 0;
}

利用模板和宏进行通用化

#include <cassert>

#define SingletonDefine(class_) \
private:\
friend class Singleton<class_>;\
class_()=default;\
class_(class_&)=delete;\
class_(class_&&)=delete;\
class_& operator=(class_&)=delete;\
class_& operator=(class_&&)=delete;\
~class(){}

template<typename T>
class Singleton
{
    inline static T* instance_ = new T();
public:
    static T* SimpleSingleton()
    {
        return instance_;
    }
};

class Cls:public Singleton<Cls>
{
    SingletonDefine(Cls)
};

int main()
{
    auto ins1 = Cls::SimpleSingleton();
    auto ins2 = Cls::SimpleSingleton();
    assert(ins1 == ins2);
    return 0;
}