C++ 单例模式

flyfish 2014-12-16

单例模式是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。

编写一个Singleton类

class Singleton(){}; 该类是空类

经过编译器处理后,C++编译器默认编写的函数代码如下

class Singleton()     
{
public:
	Singleton() {}                                 // 1 构造函数
	Singleton(const Singleton& s{}                 // 2 拷贝构造函数
	~Singleton(){}                                 // 3 析构函数
	Singleton& operator=(const Singleton& s{}      // 4 拷贝赋值函数 copy assignment
};

1 禁止用户建立对象

将Singleton类的构造函数，拷贝构造函数，拷贝赋值函数 全部声明为private，这样用户都没有权力建立对象
private:
Singleton() {};
Singleton(Singleton const&);
void operator=(Singleton const&);

2 用户可以调用 

利用public成员函数来进行访问

接口函数static Singleton& getInstance()


3 线程安全，保证对象的唯一
静态成员对象（static member objects ）是不是对象的一部分
从C++11 开始 如果静态成员声明为thread_local,每一个线程都有这样的一个object，否则在整个程序中的静态成员对象只有一个实例，也就是在C++11 如果声明了静态成员，那么这个静态成员是线程安全的。

对于什么时候创建对象有两种方案供选择
Eager evaluation和Lazy Evaluation
Eager evaluation是在程序启动时就要创建对象
最快的计算就是不计算，需要的话就是开始创建对象，不需要就不创建对象这就是惰性求值（Lazy Evaluation）
Lazy Evaluation的目的就是要最小化计算机要做的工作。

C++ 11  +  Lazy Evaluation
实现如下

class Singleton
{
public:
	static Singleton& getInstance()
	{
		static Singleton    instance;
		return instance;
	}
private:
	Singleton() {};
	Singleton(Singleton const&);
	void operator=(Singleton const&);
};

编译器不支持C++11，可以参考Boost的实现
代码在boost文件夹的位置
boost\core\noncopyable.hpp
boost\serialization\singleton.hpp


简化可以看的清楚些

class noncopyable
{
protected:
	noncopyable() {}
	~noncopyable() {}

private:
	noncopyable( const noncopyable& );
	noncopyable& operator=( const noncopyable& );
};

//noncopyable允许继承，
//利用private声明禁止子类调用赋值和拷贝构造函数
//利用protected声明禁止除了子类以外的其他类调用构造函数和析构函数
//只能由子类调用构造和析构函数构造函数和析构函数

typedef noncopyable_::noncopyable noncopyable;

class singleton_module : public boost::noncopyable
{
private:
	static bool & get_lock(){
		static bool lock = false;
		return lock;
	}
public:
	static void lock(){
		get_lock() = true;
	}
	static void unlock(){
		get_lock() = false;
	}
	static bool is_locked() {
		return get_lock();
	}
};

template<class T>
class singleton_wrapper : public T
{
public:
	static bool m_is_destroyed;
	~singleton_wrapper(){
		m_is_destroyed = true;
	}
};

template<class T>
bool detail::singleton_wrapper< T >::m_is_destroyed = false;



template <class T>
class singleton : public singleton_module
{
private:
	static T & instance;

	static void use(T const &) {}
	static T & get_instance() {
		static detail::singleton_wrapper< T > t;

		BOOST_ASSERT(! detail::singleton_wrapper< T >::m_is_destroyed);
		use(instance);
		return static_cast<T &>(t);
	}
public:
	static T & get_mutable_instance(){
		BOOST_ASSERT(! is_locked());
		return get_instance();
	}
	static const T & get_const_instance(){
		return get_instance();
	}
	static bool is_destroyed(){
		return detail::singleton_wrapper< T >::m_is_destroyed;
	}
};

template<class T>
T & singleton< T >::instance = singleton< T >::get_instance();

C++11 利用 可变参数模板 实现的单例模式

#pragma once

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("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;
//使用方式
class A
{
public:
	void test(){};
};
//使用方式

Singleton<A>::Instance();
Singleton<A>::GetInstance()->test();
Singleton<A>::DestroyInstance();