C++11实现单例模式
C++11之前的单例模式
假如我们想创建一个通用的泛型单例模式,会遇到一个问题:这个泛型单例模式要能创建所有的类型对象,但这些类型的构造函数形参可能不相同,参数个数和参数类型都不相同,这导致我们不容易做出一个所有类型都通用的单例,我们可以采用定义一些创建单例的模板函数来实现,在下面的例子中,通过定义0-2个形参的创建单例的模板函数来实现一个通用的单例模式,代码如下:
#include<stdexcept>
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<iostream>
#include<string>
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();
}