c++ －－单例的实现

        单例的实现有很多的坑，并不是简单的一个static的成员获取就算是单例了，下面详细叙述下它的坑。

        －.  懒汉模式

        

class singleton
{
	private;
		singleton();
	public:
		~singleton();
	    static singleton getInstance();
		{
				static singleton minstance;
				return minstance;
		}
};

      懒汉模式在一般使用下都不会有问题，但是，这个实现是线程不安全的。局部静态变量static singleton minstance ，编译器会在编译时期对其做处理，其结果如下：

    

static bool s_constructed = false;
  static uninitialized singleton minstance;
  if (!s_constructed) {
      s_constructed = true;
      new(&minstance) minstance; // construct it
  }

 从这里可以显而易见到存在线程安全的问题。那对于这种情况怎么处理呢？ 最简单的就是实用恶汉模式。

     二. 饿汉模式

我们知道 ， 全局成员，类静态成员，都是在main函数执行前进行初始化的，而局部静态成员是在运行到它的时候才进行初始化，所以饿汉模式就是在程序还没有运行的时候，就对单例进行初始化。

    

class singleton
{
	private;
		singleton();
		static singleton minstance;
	public:
		~singleton();
	    static singleton getInstance();
		{
				return minstance;
		}
};

singleton singleton::minstance;

这样，就不会存在编译器对于懒汉模式所做的处理了，在main函数执行前，singleton对象就已经够造了出来，这样就是一个线程安全的单例模式了。

     以为这就是单例模式最终的形态了吗？ too young too simple!!!!!

     参考了boost的单例模式实现：

     

template <typename T>
struct Singleton
{
    struct object_creator
    {
        object_creator(){ Singleton<T>::instance(); }
        inline void do_nothing()const {}
    };
 
    static object_creator create_object;
 
public:
    typedef T object_type;
    static object_type& instance()
    {
        static object_type obj;
        //据说这个do_nothing是确保create_object构造函数被调用
        //这跟模板的编译有关
        create_object.do_nothing();
        return obj;
    }
 
};
template <typename T> typename Singleton<T>::object_creator Singleton<T>::create_object;

    发现有这么一个实现，将单例对象还是做程局部静态变量，但是通过另一个内部类object_creator代替其在全局区声明初始化，这是什么原因呢？

    参考了一位大牛的blog，发现还有这么一种2b的用法：

    

//.h
class QMManager
{
protected:
    static QMManager instance_;
    QMManager();
    ~QMManager(){};
public:
    static QMManager *instance()
    {
        return &instance_;
    }
};
 
class QMSqlite
{
protected:
    static QMSqlite instance_;
    QMSqlite();
    ~QMSqlite(){};
public:
    static QMSqlite *instance()
    {
        return &instance_;
    }
    void do_something();
};
 
QMManager QMManager::instance_;
QMSqlite QMSqlite::instance_;

//.cpp
QMManager::QMManager()
{
    printf("QMManager constructor\n");
    QMSqlite::instance()->do_something();
}
 
QMSqlite::QMSqlite()
{
    printf("QMSqlite constructor\n");
}
void QMSqlite::do_something()
{
    printf("QMSqlite do_something\n");
}

就是在构造类静态成员的时候，它的构造函数有可能去调用另一个单例模式的静态成员，以便调用其方法。可以发现，这是存在问题的，在执行main函数之前，两个静态成员QManager和QMsSqlite的构造是有先后顺序的，QManager先进行的初始化，这时候，当调用QManager的构造函数的时候，去主动获取QMSqlite的单例，并调用其成员，但是，这时候QMSqlite的单例对象instance_还没有初始化，就是说，现在调用的是一个为初始化的变量，这当然存在问题了。 解决的办法就是，将这两个变量的初始化工作放在局部变量，让程序运行到的时候去初始化。但是这样就又会出现懒汉模式中的线程不安全的问题，所以，讨巧的做法就是把他们封装进另一个静态成员的构造中。

    最终的单例模式：

   

class singleton
{
	private:
		singleton();
	    class create_object
		{
			public:
				create_object(){
						singleton::getInstance();
				}
		};
		static create_object m_createobj;	
	public:
		~singleton();
	    static singleton& getInstance();
		void eat()
		{
			printf("fuck\n");
		}	

};

singleton::create_object singleton::m_createobj; 

singleton::singleton()
{

}

singleton::~singleton()
{

}

singleton& singleton::getInstance()
{
	static singleton m_instance;
	return m_instance;
}

    小小的单例模式，有这么多的坑

   贴一段模仿boost的实现:

    

#include "stdafx.h"
#include <iostream>


using namespace std;

class signletonSt
{
private:
	signletonSt(){}
	~signletonSt(){}
	struct create_signletonst
	{
		create_signletonst()
		{
			signletonSt::getInstance();
		}
	};
	static create_signletonst m_creator;
	
public:
	static signletonSt* getInstance()
	{
		static signletonSt* m_st = NULL;
		if (!m_st)
		{
			cout << "first new" << endl;
			m_st = new signletonSt();
		}
		else
		{
			cout << "has instanced" << endl;
			return m_st;
		}
	}
	
};

signletonSt::create_signletonst signletonSt::m_creator;

int _tmain(int argc, _TCHAR* argv[])
{
	signletonSt* m1 = signletonSt::getInstance();
	return 0;
}