设计模式——单例模式

单例模式，即保证一个类仅可以有一个实例化对象，并且提供一个可以访问它的全局接口。

主要解决的问题：一个全局使用的类频繁的创建与销毁

什么时候使用：想控制实例数目，节省系统资源时

单例模式的实现方式分为两种，懒汉和饿汉

单例模式的实现要点：

• 全局只有一个static特性实例，同时禁止用户自己声明并定义实例
• 线程安全
• 禁止赋值和拷贝
• 用户使用static成员函数通过接口获取实例

1.懒汉单例模式

不到万不得已就不会去实例化类，也就是说在第一次用到类实例时才会去实例化。访问量较小，甚至可能不回去访问的情况下，采用懒汉模式，这是以时间换空间。

线程不安全的懒汉单例模式：

#include<iostream>
using namespace std;
class Singleidler
{
	public:
	~Singleidler()
	{
		cout<<"destroystructor called"<<endl;
	}
	static Singleidler* get_instance()
	{
		if(ptr_instance==nullptr)
		{
			ptr_instance=new Singleidler;
		}
		return ptr_instance;
	}
	void use() const
	{
		cout<<"using"<<endl;
	}
private:
	Singleidler()
	{
		cout<<"constructor called!"<<endl;
	}
	 Singleidler(const Singleidler&)=delete;//禁止访问拷贝构造
     Singleidler& operator=(const Singleidler&)=delete;//禁止赋值
	 static Singleidler* ptr_instance;
};
Singleidler* Singleidler::ptr_instance=nullptr;
int main()
{
	Singleidler* instance =Singleidler::get_instance();
	Singleidler* instance2 =Singleidler::get_instance();
	return 0;
}

线程安全的懒汉单例模式：

#include <iostream>
#include <memory>
#include <mutex>  
using namespace std;
class Singleidler{
public:
    typedef shared_ptr<Singleidler> Ptr;
    ~Singleidler(){
     cout<<"destructor called!"<<endl;
    }
    Singleidler(Singleidler&)=delete;
    Singleidler& operator=(const Singleidler&)=delete;
    static Ptr get_instance(){

        if(ptr_instance==nullptr){
            lock_guard<mutex> lk(m_mutex);
            if(ptr_instance == nullptr){
              ptr_instance = shared_ptr<Singleidler>(new Singleidler);
            }
            return ptr_instance;
        }
    }


private:
    Singleidler(){
    cout<<"constructor called!"<<endl;
    }
    static Ptr ptr_instance;
    static mutex m_mutex;
};
Singleidler::Ptr Singleidler::ptr_instance = nullptr;
mutex Singleidler::m_mutex;

int main(){
    Singleidler::Ptr instance = Singleidler::get_instance();
    Singleidler::Ptr instance2 = Singleidler::get_instance();
    return 0;
}

2、饿汉单例模式

饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

class Singleton
{
public:
    static Singleton* getInstance();
private:
    Singleton(){}                                
    Singleton(const Singleton&) = delete;            
    Singleton& operator=(const Singleton&) = delete; 
​
    static Singleton* m_pSingleton;
};
​
Singleton* Singleton::m_pSingleton = new Singleton();
​
Singleton* Singleton::getInstance()
{
    return m_pSingleton;
}