网站建设企业谁家好,个人中心页面设计html,苏州企业网站建设开发与制作,苏州公司网站单例模式保证一个类仅有一个实例#xff0c;并提供一个访问它的全局访问点。 C11之前#xff0c;实现一个通用的泛型单例模式时#xff0c;会遇到一个问题#xff1a;这个泛型单例要能够创建所有的类型对象#xff0c;但是这些类型的构造函数形参可能尽不相同#xff0c;… 单例模式保证一个类仅有一个实例并提供一个访问它的全局访问点。 C11之前实现一个通用的泛型单例模式时会遇到一个问题这个泛型单例要能够创建所有的类型对象但是这些类型的构造函数形参可能尽不相同参数个数和参数类型可能都不相同这导致我们不容易做一个所有类型都通用的单例。一种方法是通过定义一些创建单例的模板函数来实现。在一般情况下类型的构造函数形参不超过6个所以可以通过定义0~6个形参的创建单例的模板函数来实现一个通用的单例模式代码如下所示
#include iostream
using namespace std;templatetypename T
class Singleton
{
public:///支持0个参数的构造函数static T* Instance(){if (m_pInstance nullptr){m_pInstance new T();}return m_pInstance;}///支持1个参数的构造函数templatetypename T0static T* Instance(T0 arg0){if (m_pInstance nullptr){m_pInstance new T(arg0);}return m_pInstance;}///支持2个参数的构造函数templatetypename T0, typename T1static T* Instance(T0 arg0, T1 arg1){if (m_pInstance nullptr){m_pInstance new T(arg0, arg1);}return m_pInstance;}///支持3个参数的构造函数templatetypename T0, typename T1, typename T2static T* Instance(T0 arg0, T1 arg1, T2 arg2){if (m_pInstance nullptr){m_pInstance new T(arg0, arg1, arg2);}return m_pInstance;}///支持4个参数的构造函数templatetypename T0, typename T1, typename T2, typename T3static T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3){if (m_pInstance nullptr){m_pInstance new T(arg0, arg1, arg2, arg3);}return m_pInstance;}///支持5个参数的构造函数templatetypename T0, typename T1, typename T2, typename T3, typename T4static T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4){if (m_pInstance nullptr){m_pInstance new T(arg0, arg1, arg2, arg3, arg4);}return m_pInstance;}///支持6个参数的构造函数templatetypename T0, typename T1, typename T2, typename T3, typename T4, typename T5static T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5){if (m_pInstance nullptr){m_pInstance new T(arg0, arg1, arg2, arg3, arg4, arg5);}return m_pInstance;}///获取单例static T* GetInstance(){if (m_pInstance nullptr){std::logic_error(the instance is not init, please initialize the instance first);}return m_pInstance;}///释放单例static void DestoryInstance(){delete m_pInstance;m_pInstance nullptr;}private:///不允许复制和赋值Singleton(void);virtual ~Singleton(void);Singleton(const Singleton);Singleton operator(const Singleton);private:static T* m_pInstance;
};templateclass T
T* SingletonT::m_pInstance nullptr;class A
{
public:A(){cout construct A.... endl;}
};class B
{
public:B(int x){m_x x;cout construct B.... endl;}
private:int m_x;
};class C
{
public:C(int x, double db){m_x x;m_db db;cout construct C.... endl;}
private:int m_x;int m_db;
};int main()
{///创建A类型的单例SingletonA::Instance();///创建B类型的单例SingletonB::Instance(1);///创建C类型的单例SingletonC::Instance(1, 2.0);SingletonA::DestoryInstance();SingletonB::DestoryInstance();SingletonC::DestoryInstance();return 0;
} 从测试代码中可以看到这个SingletonT可以创建大部分类型支持不超过6个参数的类型。不过从实现代码中可以看到有很多重复的模板定义这种定义繁琐而又重复当参数超过6个时我们不得不再增加模板定义。这种预先定义足够多的模板函数的方法显得重复又不够灵活。 C11d可变参数模板正好可以消除这种重复同时支持完美转发即避免不必要的内存复制提高性能又增加了灵活性。C11实现的一个简洁通用的单例模式如下所示
#include iostream
#include string
#include thread
#include mutex
#include string.h
using namespace std;templatetypename T
class Singleton
{
public:templatetypename ...Argsstatic T* Instance(Args ...args){if (m_pInstance nullptr) {///完美转发m_pInstance new T(std::forwardArgs(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 DestoryInstance(){delete m_pInstance ;m_pInstance nullptr;}private:Singleton(void);virtual ~Singleton();Singleton(const Singleton);Singleton operator(const Singleton);private:static T* m_pInstance;
};templateclass T
T* SingletonT::m_pInstance nullptr;class A
{
public:A(const string ){cout A lvalue endl;}A(string ){cout A rvalue endl;}
};class B
{
public:B(const string ){cout B lvalue endl;}B(string ){cout B rvalue endl;}
};class C
{
public:C(int x, int y){cout C construct endl;}void func(){cout class C call func... endl;}
};std::once_flag init_flagA;
std::once_flag init_flagB;
std::once_flag init_flagC;void func1()
{///为了保证在多线程环境中某个函数仅被调用一次比如需要初始化某个对象而这个对象只能初始化一次就可以用std::call_once来保证在多线程环境中只被调用一次std::call_once(init_flagA, []() {SingletonA::Instance(123);});std::call_once(init_flagB, []() {SingletonB::Instance(std::move(abc));});std::call_once(init_flagC, []() {SingletonC::Instance(1, 2);});
}void func2()
{///为了保证在多线程环境中某个函数仅被调用一次比如需要初始化某个对象而这个对象只能初始化一次就可以用std::call_once来保证在多线程环境中只被调用一次std::call_once(init_flagA, []() {SingletonA::Instance(456);});std::call_once(init_flagB, []() {SingletonB::Instance(std::move(efg));});std::call_once(init_flagC, []() {SingletonC::Instance(3, 4);});
}int main()
{thread t1(func1);thread t2(func1);t1.join();t2.join();SingletonC::GetInstance()-func();getchar();SingletonA::DestoryInstance();SingletonB::DestoryInstance();SingletonC::DestoryInstance();return 0;
} 可以看到C11版本的通用单例模式的实现没有了重复的模板定义支持任意个数参数的类型创建不用再担心模板函数定义得不够还支持完美转发无论是左值还是右值都能转发到正确的构造函数中通过右值引用的移动语义还能进一步提高性能简洁而优雅。
