关于单例继承的问题

[小塔-皂荚花]

我们在做东西的时候进程遇到单例的问题，一个项目有时候有很多的单例类，单例的实现不是都差不多吗，就那几条规则，但是你每次写一个单例类都需要那么做上，是很麻烦，我是想问有没有什么简便的方法啊。如果我写一个父类的话，做成单例的，那么子类也不会是单例的啊，如果我将这个单例的父类写成是模板类，子类是应该去继承啊，还是怎么样，具体的代码是怎么样的。我吧这个模板的单例父类贴上来，大家看看应该怎么做。

/************************************************************************/
/* 单例模版                                                                     */
/************************************************************************/
#ifndef _SINGLETON_H_
#define _SINGLETON_H_

template<class T>
class  Singleton
{
private:
	static T * iInstance;
public:
	static T * getInstance();
	static void FreeInstance();
};

template<class T>
T * Singleton<T>::iInstance=NULL;

template<class T>
T * Singleton<T>::getInstance()
{
	if(iInstance == 0)
	{
		iInstance=new T();
	}

	return iInstance;
}

template<class T>
void Singleton<T>::FreeInstance()
{
	if(iInstance)
	{	
		delete iInstance;
		iInstance=NULL;
	}
}

#endif

谢啦，等待大神的回答。

[小塔-皂荚花]

怎么没人，不可能吧。

[AndyStevens]

class deserved : public Singleton<deserved>

[ningto.com]

自己参考改下吧：

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

#include "CommonHeader.h"

#include <crtdbg.h>

#include "thread/LocalMutex.h"
#include "thread/AutoLock.h"

//
// Template that realize singleton pattern which does not supports "lazy"
// initialization.
//
// Remark:
// To use this pattern you must create singleton instance by your own hands,
// it means that this realization of singleton does not support "lazy" initialization.
//

template<class T> class Singleton {
public:
  Singleton() {
    AutoLock l(&m_instanceMutex);

    if (s_instance == 0) {
      s_instance = (T*)this;
    } else {
      _ASSERT(FALSE);
    }
  }

  virtual ~Singleton() {
    AutoLock l(&m_instanceMutex);

    s_instance = 0;
  }

  static T* getInstance() {
    {
      AutoLock l(&m_instanceMutex);

      if (s_instance == 0) {
        _ASSERT(FALSE);
      }
    }

    return (T*)s_instance;
  }

private:
  static LocalMutex m_instanceMutex;

  static void* s_instance;
};

template<class T> LocalMutex Singleton<T>::m_instanceMutex;
template<class T> void *Singleton<T>::s_instance = 0;

#endif

[小塔-皂荚花]

引用 2 楼 Automation_dmu 的回复:

class deserved : public Singleton<deserved>

我刚刚试了，这个时候还是可以new出来对象的，如果将构造函数私有了的话，程序是编译失败的。

[AndyStevens]

class YouClass
{
	friend Singleton<YouClass>;
private:
	YouClass(){};
	YouClass(const YouClass&);
};

//main.cpp
YouClass* a = Singleton<YouClass>::getInstance();

[小塔-皂荚花]

引用 5 楼 Automation_dmu 的回复:

class YouClass
{
	friend Singleton<YouClass>;
private:
	YouClass(){};
	YouClass(const YouClass&);
};

//main.cpp
YouClass* a = Singleton<YouClass>::getInstance();

你的方法给了我启示，不过还需要继承一下才行！方法如下：http://www.zaojiahua.com/singleton.html皂荚花。

[小塔-皂荚花]

谢谢各位了！

[苍蝇①号]

template <typename T>
class SingletonBase
{

public:
    static T& Instance()
    {
        if (!is_alive_) {
            fprintf(stderr, "Singleton has been destroyed\n");
            abort();
        }

        if (!instance_)
        {
            ScopedLocker<Mutex> locker(lock_);
            if (!instance_)
            {
                T* p = new T();
                MemoryWriteBarrier();
                instance_ = p;
                atexit(Destroy);
            }
        }
        return *instance_;
    }

    template <typename A1>
    static T& Instance(A1& a1)
    {
        if (!is_alive_) {
            fprintf(stderr, "Singleton has been destroyed\n");
            abort();
        }

        // double check locking optimize
        if (!instance_)
        {
            ScopedLocker<Mutex> locker(lock_);
            if (!instance_)
            {
                T* p = new T(a1);
                MemoryWriteBarrier();
                instance_ = p;
                atexit(Destroy);
            }
        }
        return *instance_;
    }

    static bool IsAlive()
    {
        return instance_ != NULL;
    }

protected:
    SingletonBase() {}
    ~SingletonBase() {}

private:
    static void Destroy()
    {
        is_alive_ = false;
        // need not locking
        if (instance_)
        {
            delete instance_;
            instance_ = NULL;
        }
    }

private:
    static Mutex lock_;
    static T* volatile instance_;
    static bool volatile is_alive_;

    DECLARE_UNCOPYABLE(SingletonBase);
};

template <typename T>
Mutex SingletonBase<T>::lock_;

template <typename T>
T* volatile SingletonBase<T>::instance_;

template <typename T>
bool volatile SingletonBase<T>::is_alive_ = true;

template <typename T>
class Singleton
    : public SingletonBase<T>{ };