C++ 单例模式

有缺陷的懒汉式

#include <iostream>
using namespace std;


class Single{
    private:
        /*构造函数私有化*/
        Single(){
            cout<<"constructor created"<<endl;
        }
        /*禁用拷贝构造函数*/
        Single(Single &) = delete;
        /*禁用赋值*/
        Single& operator=(const Single&) = delete;
        /*创建一个实例,static 指针*/
        static Single *instance_ptr;
        /*创建一个数据成员*/
        int val;
    public:
        /*析构函数*/
        ~Single(){
            cout<<"constructor freed"<<endl;
        }
        /*提供获取对象接口*/
        static Single * get_instance(){
            /*判断指针是为空，只允许创建唯一对象*/
            if(instance_ptr == nullptr){
                instance_ptr = new Single;
            }
             return instance_ptr;
        }
        /*设置数据成员的值*/
        void setVal(int val){
            this->val = val;
        }
        /*获取数据成员的值*/
        int getVal(){
            return this->val;
        }
};

/*静态数据成员初始化*/
Single* Single::instance_ptr = nullptr;

int main()
{
    Single *ptr = Single::get_instance();
    Single *ptr1 = Single::get_instance();
    ptr->setVal(100);
    cout<<ptr1->getVal()<<endl;
    return 0;
}

编译时：g++ xxx.cpp -std=c++11
运行结果

constructor created
100

从运行结果可以看出，虽然获取了两次实例，但构造函数只被调用了一次，说明只能够获取唯一的实例；通过setVal与getVal两个操作，可以看出两次得到的是同一个实例，实现了全局变量的效果。但该方法存在两个比较明显的问题：
1、内存泄漏，由结果显示，析构函数一直没有被调用，这是因为new动态开辟的空间需要delete去释放，而在实际的开发过程当中，并不确定该什么时候去释放，因为你不知道你是否还需要使用它，解决该问题的办法就是智能指针。
2、线程不安全，当多个线程同时获取实例时，可能会在if(instance_ptr == nullptr)时发生线程的切换，判断的时候是没有创建实例的，当切换回来的时候可能其他线程已经创建实例，此时创建的实例可能就不再是唯一的了，解决这一问题的办法就是上互斥锁。

线程安全、内存安全的懒汉式单例 （智能指针，锁）

#include <memory>
#include <pthread.h>
#include <iostream>
using namespace std;


class Single{
    private:
        /*构造函数私有化*/
        Single(){
            cout<<"constructor created"<<endl;
        }
        /*禁用拷贝构造函数*/
        Single(Single &) = delete;
        /*禁用赋值*/
        Single& operator=(const Single&) = delete;
        /*创建一个实例,static 智能指针*/
        static shared_ptr<Single> instance_ptr;
        /*创建一个数据成员*/
        int val;
        /*创建锁*/
        static pthread_mutex_t mutex;
    public:
        /*析构函数*/
        ~Single(){
            cout<<"constructor freed"<<endl;
            /*销毁锁*/
            pthread_mutex_destroy(&mutex);
        }
        /*提供获取对象接口*/
        static shared_ptr<Single> get_instance(){
            /*加锁*/
            pthread_mutex_lock(&mutex);
            /*判断指针是为空，只允许创建唯一对象*/
            if(instance_ptr == nullptr){
                instance_ptr = shared_ptr<Single>(new Single);
            }
            /*解锁*/
            pthread_mutex_unlock(&mutex);
            return instance_ptr;
        }
        /*设置数据成员的值*/
        void setVal(int val){
            this->val = val;
        }
        /*获取数据成员的值*/
        int getVal(){
            return this->val;
        }
};

/*静态数据成员初始化*/
pthread_mutex_t Single::mutex = PTHREAD_MUTEX_INITIALIZER;
shared_ptr<Single> Single::instance_ptr = nullptr;

int main()
{
    shared_ptr<Single> instance = Single::get_instance();
    shared_ptr<Single> instance1 = Single::get_instance();
    instance->setVal(100);
    cout<<instance1->getVal()<<endl;
    return 0;
}

结果：

constructor created
100
constructor freed

最推荐的懒汉式单例(magic static )——局部静态变量

#include <iostream>
using namespace std;


class Single{
    private:
        /*构造函数私有化*/
        Single(){
            cout<<"constructor created"<<endl;
        }
        /*禁用拷贝构造函数*/
        Single(Single &) = delete;
        /*禁用赋值*/
        Single& operator=(const Single&) = delete;
        /*创建一个数据成员*/
        int val;
    public:
        /*析构函数*/
        ~Single(){
            cout<<"constructor freed"<<endl;
        }
        /*提供获取对象接口*/
        static Single& get_instance(){
            static Single instance;
            return instance;
        }
        /*设置数据成员的值*/
        void setVal(int val){
            this->val = val;
        }
        /*获取数据成员的值*/
        int getVal(){
            return this->val;
        }
};


int main()
{
    Single& instance = Single::get_instance();
    Single& instance1 = Single::get_instance();
    instance.setVal(100);
    cout<<instance1.getVal()<<endl;
    return 0;
}

结果：

constructor created
100
constructor freed