C++实现单例模式

转载一篇我自己写在CSDN上的一篇文章

单例模式

一、non thread safe

//-----------------------------------------------懒汉模式
//Singleton_lazy.h
#pragma once
#include <memory>
class Singleton_lazy{
private:
    static std::unique_ptr<Singleton_lazy> instance;
    Singleton_lazy() = default;
    Singleton_lazy(const Singleton_lazy&) = delete;
    Singleton_lazy& operator=(const Singleton_lazy&) = delete;
    Singleton_lazy(const Singleton_lazy&&) = delete;
    Singleton_lazy& operator=(const Singleton_lazy&&) = delete;
private://资源
    int abc = 0
public:
    static Singleton_lazy* getInstance(){
        if(!instance)
            instance.reset(new Singleton_lazy);
        return instance.get();
    }
    int doSomething(){
        return abc;
    }
    void doSomthingadd(){
        //成员函数做事
        abc++;
    }
};
//Singleton_lazy.cpp
#include "Singleton_lazy.h"
std::unique_ptr<Singleton_lazy> Singleton_lazy::instance(nullptr);


//-----------------------------------------------饿汉模式
//Singleton_eager.h
#pragma once
#include <memory>
class Singleton_eager{
private:
    static std::unique_ptr<Singleton_eager> instance;
    Singleton_eager() = default;
    Singleton_eager(const Singleton_eager&) = delete;
    Singleton_eager& operator=(const Singleton_eager&) = delete;
    Singleton_eager(const Singleton_eager&&) = delete;
    Singleton_eager& operator=(const Singleton_eager&&) = delete;
private://资源
    int abc = 0;
public:
    static Singleton_eager* getInstance(){
        return instance.get();
    }
    int doSomething(){
        //成员函数做事
        return abc;
    }
    void doSomthingadd(){
        //成员函数做事
        abc++;
    }
};
//Singleton_lazy.cpp
#include "Singleton_eager.h"
std::unique_ptr<Singleton_eager> Singleton_eager::instance(new Singleton_eager);

二、thread safe

//-----------------------------------------------懒汉模式
//Singleton_lazy.h
#pragma once
#include <memory>
#include <mutex>
class Singleton_lazy{
private:
    static std::unique_ptr<Singleton_lazy> instance;
    static std::mutex mut;
    static std::once_flag initFlag;
    Singleton_lazy() = default;
    Singleton_lazy(const Singleton_lazy&) = delete;
    Singleton_lazy& operator=(const Singleton_lazy&) = delete;
    Singleton_lazy(const Singleton_lazy&&) = delete;
    Singleton_lazy& operator=(const Singleton_lazy&&) = delete;
private://资源
    int abc = 0;
public:
    static Singleton_lazy* getInstance(){
        //getInstance本身是线程安全的，因为instance成员只读
        //call once 保证单次初始化
        std::call_once(initFlag, [&](){
                instance.reset(new Singleton_lazy);
            }
        );
        return instance.get();
    }
    int doSomething(){
        std::lock_guard<std::mutex> lg(mut);
        //成员函数做事
        return abc;
    }
    void doSomthingadd(){
        std::lock_guard<std::mutex> lg(mut);
        //成员函数做事
        abc++;
    }
};
//Singleton_lazy.cpp
#include "Singleton_lazy.h"
std::unique_ptr<Singleton_lazy> Singleton_lazy::instance(nullptr);
std::mutex Singleton_lazy::mut;
std::once_flag Singleton_lazy::initFlag;


//-----------------------------------------------饿汉模式
//Singleton_eager.h
#pragma once
#include <memory>
#include <mutex>
class Singleton_eager{
private:
    static std::unique_ptr<Singleton_eager> instance;
    static std::mutex mut;
    Singleton_eager() = default;
    Singleton_eager(const Singleton_eager&) = delete;
    Singleton_eager& operator=(const Singleton_eager&) = delete;
    Singleton_eager(const Singleton_eager&&) = delete;
    Singleton_eager& operator=(const Singleton_eager&&) = delete;
private://资源
    int abc = 0;
public:
    static Singleton_eager* getInstance(){
        //getInstance本身是线程安全的，因为instance成员只读
        //每有重复初始化的问题
        return instance.get();
    }
    int doSomething(){
        std::lock_guard<std::mutex> lg(mut);
        //成员函数做事
        return abc;
    }
    void doSomthingadd(){
        std::lock_guard<std::mutex> lg(mut);
        //成员函数做事
        abc++;
    }
};
//Singleton_eager.cpp
#include "Singleton_.h"
std::unique_ptr<Singleton_eager> Singleton_eager::instance(new Singleton_eager);
std::mutex Singleton_eager::mut;