王子原创作品。转载请注明出处http://blog.csdn.net/wang19840301
一、四种常见的单例：
1、没有构造函数（DEFINE_SINGLETON_DEFAULT）；
2、有构造函数，构造函数没有参数（DEFINE_SINGLETON_CONSTRUCT_NO_PARAM）；
3、有构造函数，构造函数有没有参数版本（DEFINE_SINGLETON_CONSTRUCT_WITH_DEFAULT）；
4、有构造函数，构造函数都有参数（DEFINE_SINGLETON_CONSTRUCT）；
通过宏定义巧妙实现，使用也很方便！
二、调用代码如下：
#include "stdafx.h"
#include "Singleton.h"
class MyClass1
{
DEFINE_SINGLETON_DEFAULT(MyClass1);
public:
void f() { printf("My class 1 function\n"); };
};
class MyClass2
{
DEFINE_SINGLETON_CONSTRUCT_NO_PARAM(MyClass2);
public:
void f() { printf("My class 2 function\n"); };
};
MyClass2::MyClass2() { }
class MyClass3
{
DEFINE_SINGLETON_CONSTRUCT_WITH_DEFAULT(MyClass3);
private:
MyClass3(int a = 3) { a_ = a; }
int a_;
public:
void f() { printf("My class 3 function, a=%d\n", a_); };
};
class MyClass4
{
DEFINE_SINGLETON_CONSTRUCT(MyClass4);
private:
MyClass4(int a) { a_ = a; }
int a_;
public:
void f() { printf("My class 4 function, a=%d\n", a_); };
};
int _tmain(int argc, char* argv[])
{
MyClass1::singleton::GetInstance()->f();
MyClass2::singleton::GetInstance()->f();
//MyClass3::singleton::GetInstance()->f(); // normal
MyClass3::singleton::Create(8);
MyClass3::singleton::GetInstance()->f();
//MyClass4::singleton::GetInstance()->f(); // error
MyClass4::singleton::Create(18);
MyClass4::singleton::GetInstance()->f();
system("pause");
}
注意：
1、MyClass3类可以不用调用Create方法，而直接调用MyClass3::singleton::GetInstance()->f()方法。这种情况下会调用无参构造函数；
2、MyClass4类必须调用Create方法初始化，否则会报内存错误；
三、singleton源代码如下：
#pragma once
#include <mutex>
namespace klicen
{
namespace utils
{
class noncopyable
{
protected:
noncopyable() = default;
~noncopyable() = default;
noncopyable(const noncopyable&) = delete;
noncopyable& operator=(const noncopyable&) = delete;
};
template <typename T>
class Singleton : private noncopyable
{
public:
static T* GetInstance()
{
// double check
if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
instance_ = new T;
}
}
return instance_;
}
private:
Singleton();
static T* instance_;
static std::mutex mutex_;
};
template <typename T> T* Singleton<T>::instance_ = nullptr;
template <typename T> std::mutex Singleton<T>::mutex_;
#define DEFINE_SINGLETON_DEFAULT(class_name); \
public: \
friend class klicen::utils::Singleton<class_name>; \
typedef klicen::utils::Singleton<class_name> singleton; \
private: \
class_name() {} \
virtual ~class_name() {} \
class_name(const class_name&){} \
class_name& operator=(const class_name&){}
template <typename T>
class SingletonConstruct : private noncopyable
{
public:
static T* GetInstance()
{
/*if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
throw std::exception("Get singleton failed");
}
}*/
return instance_;
}
template <typename... Args>
static void Create(Args&&... args)
{
if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
instance_ = new T(std::forward<Args>(args)...);
}
}
}
private:
SingletonConstruct();
static T* instance_;
static std::mutex mutex_;
};
template <typename T> T* SingletonConstruct<T>::instance_ = nullptr;
template <typename T> std::mutex SingletonConstruct<T>::mutex_;
#define DEFINE_SINGLETON_CONSTRUCT(class_name); \
public: \
friend class klicen::utils::SingletonConstruct<class_name>; \
typedef klicen::utils::SingletonConstruct<class_name> singleton; \
private: \
virtual ~class_name() {} \
class_name& operator=(const class_name&){}
template <typename T>
class SingletonConstructNoParam : private noncopyable
{
public:
static T* GetInstance()
{
if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
instance_ = new T;
}
}
return instance_;
}
private:
SingletonConstructNoParam();
static T* instance_;
static std::mutex mutex_;
};
template <typename T> T* SingletonConstructNoParam<T>::instance_ = nullptr;
template <typename T> std::mutex SingletonConstructNoParam<T>::mutex_;
#define DEFINE_SINGLETON_CONSTRUCT_NO_PARAM(class_name); \
public: \
friend class klicen::utils::SingletonConstructNoParam<class_name>; \
typedef klicen::utils::SingletonConstructNoParam<class_name> singleton; \
private: \
class_name(); \
virtual ~class_name() {} \
class_name& operator=(const class_name&){}
template <typename T>
class SingletonConstructWithDefault : private noncopyable
{
public:
static T* GetInstance()
{
if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
instance_ = new T;
}
}
return instance_;
}
template <typename... Args>
static void Create(Args&&... args)
{
if (nullptr == instance_)
{
std::lock_guard<std::mutex> lock(mutex_);
if (nullptr == instance_)
{
instance_ = new T(std::forward<Args>(args)...);
}
}
}
private:
SingletonConstructWithDefault();
static T* instance_;
static std::mutex mutex_;
};
template <typename T> T* SingletonConstructWithDefault<T>::instance_ = nullptr;
template <typename T> std::mutex SingletonConstructWithDefault<T>::mutex_;
#define DEFINE_SINGLETON_CONSTRUCT_WITH_DEFAULT(class_name); \
public: \
friend class klicen::utils::SingletonConstructWithDefault<class_name>; \
typedef klicen::utils::SingletonConstructWithDefault<class_name> singleton; \
private: \
virtual ~class_name() {} \
class_name& operator=(const class_name&){}
} // namespace utils
} // namespace klicen