设计模式之单例模式

问题：单例模式是最常用的设计模式之一，对单例的理解：一个类有且只有一个对象（只能实例化一次，不能进行拷贝，赋值），并提供一个全局访问接口。例如windows中的任务管理器，打印机管理程序等。

实现1：

class Singleton
{
public:
	//返回局部变量的引用，避免忘记释放内存
    static Singleton &getInstance();
	
private:
    Singleton();
    ~Singleton();
    Singleton(const Singleton &); //重写函数，避免复制构造
    Singleton &operator =(const Singleton &);//重写函数，避免赋值构造
};
Singleton &Singleton::getInstance()
{
   static Singleton siglton;
   return siglton;
}

实现2：可变参数模板，我们写单例模式时，会遇到一个问题，多种类型的单例可能需要创建多个类型的单例，主要是因为创建单例函的构造函数无法统一，构造函数的参数不一样，使用可变模板参数可解决这一问题。

template <typename T>
class Singleton
{
public:
　template<typename... Args>
　　static T* GetInstance(Args&&... args)
　　{
        if(m_pInstance==nullptr)
        {
            m_pInstance = new T(std::forward<Args>(args)...);
        }
        return m_pInstance;

    }

private:
    static void DestroyInstance()
    {
        delete m_pInstance;
        m_pInstance = nullptr;
    }
	
private:

	Singleton(void);
	virtual ~Singleton(void);
	Singleton(const Singleton&);
	Singleton& operator = (const Singleton&);
private:
    static T* m_pInstance;
};

template <class T> T*  Singleton<T>::m_pInstance = nullptr;

 实现3：由于原来的接口中，单例对象的初始化和取值都是一个接口，可能会遭到误用，单例用法为：先初始化，后面取值，如果中途销毁单例的化，需要重新取值，如果没有初始化就会抛出一个异常。

#include <map>
#include <string>
#include <memory>
using namespace std;

template < typename T, typename K = string>
class Multiton
{
public:
    template<typename... Args>
    static std::shared_ptr<T> Instance(const K& key, Args&&... args)
    {
        return GetInstance(key, std::forward<Args>(args)...);
    }

    template<typename... Args>
    static std::shared_ptr<T> Instance(K&& key, Args&&... args)
    {
        return GetInstance(key, std::forward<Args>(args)...);
    }
private:
    template<typename Key, typename... Args>
    static std::shared_ptr<T> GetInstance(Key&& key, Args&&...args)
    {
        std::shared_ptr<T> instance = nullptr;
        auto it = m_map.find(key);
        if (it == m_map.end())
        {
            instance = std::make_shared<T>(std::forward<Args>(args)...);
            m_map.emplace(key, instance);
        }
        else
        {
            instance = it->second;
        }

        return instance;
    }

private:
    Multiton(void);
    virtual ~Multiton(void);
    Multiton(const Multiton&);
    Multiton& operator = (const Multiton&);
private:
    static map<K, std::shared_ptr<T>> m_map;
};

template <typename T, typename K>
map<K, std::shared_ptr<T>> Multiton<T, K>::m_map;

参考： 点击打开链接