C++11实现单例模式

C++11之前的单例模式

假如我们想创建一个通用的泛型单例模式，会遇到一个问题：这个泛型单例模式要能创建所有的类型对象，但这些类型的构造函数形参可能不相同，参数个数和参数类型都不相同，这导致我们不容易做出一个所有类型都通用的单例，我们可以采用定义一些创建单例的模板函数来实现，在下面的例子中，通过定义0-2个形参的创建单例的模板函数来实现一个通用的单例模式，代码如下：

#include
template <typename T>
class Singleton
{
public:
  //0
  static T* Instance()
  {
    if(m_pInstance==nullptr)
      m_pInstance=new T();
    return m_pInstance;
  }
  //1
  template<typename T0>
  static T* Instance(T0 arg0)
  {
    if(m_pInstance==nullptr)
      m_pInstance=new T(arg0);
    return m_pInstance;
  }
  template<typename T0,typename T1>
  static T* Instance(T0 arg0,T1 arg1)
  {
    if(m_pInstance==nullptr)
      m_pInstance=new T(arg0,arg1);
    return m_pInstance;
  }
  //获取单例
  static T* GetInstance()
  {
    if(m_pInstance==nullptr)
      throw std::logic_error("the instance is not init,please initalize the instance first");
    return m_pInstance;
  }
  //释放单例
  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;
struct A
{
  A(){}
};
struct B
{
  B(int x){}
};
struct C
{
  C(int x,double y){}
};
int main()
{
  Singleton<A>::Instance();
  Singleton<B>::Instance(1);
  Singleton<C>::Instance(1,3.1);
  Singleton<A>::DestroyInstance();
  Singleton<B>::DestroyInstance();
  Singleton<C>::DestroyInstance();
}

从测试代码可以看出，有很多重复的模板定义，当参数个数超过2个时，我们就需要添加模板定义，预先定义足够多的模板函数的方法显得重复且不够灵活
C++11的可变参数模板可以消除这种重复，同时支持完美转发，既避免了不必要的内存复制提高性能，又增加了灵活性。

C++11实现单例模式

#include
#include
using namespace std;
template <typename T>
class Singleton
{
public:
  template<typename... Args>
  static T* Instance(Args&&... args)
  {
    if(m_pInstance==nullptr)
      m_pInstance=new T(std::forward<Args>(args)...);
    return m_pInstance;
  }
  static T* GetInstance()
  {
    if(m_pInstance==nullptr)
      throw std::logic_error("the instance is not init,please initialize the instance first");
    return m_pInstance;
  }
  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;
struct A
{
  A(const string&) {cout<<"lvaue"<<endl;}
  A(string&& x) {cout<<"rvaue"<<endl;}
};
struct B
{
  B(const string&)
  {
    cout<<"lvaue"<<endl;
  }
  B(string&& x)
  {
    cout<<"rvaue"<<endl;
  }
};
struct C
{
  C(int x,double y)
  {
  }
  void func()
  {
    cout<<"test"<<endl;
  }
};
int main()
{
  string str="bb";
  Singleton<A>::Instance(str);
  Singleton<B>::Instance(std::move(str));
  Singleton<C>::Instance(1,3.14);
  Singleton<C>::GetInstance()->func();
  Singleton<A>::DestroyInstance();
  Singleton<B>::DestroyInstance();
  Singleton<C>::DestroyInstance();

}