用模板写一个单利类，怎么写？
如题，，，，，，， 啊啊啊
[解决办法]
OK, I spend a few minutes and wrote this one, is it what you want?

template<typename T>
class SingleTon
{
public:
  static SingleTon& Instance()
  {
    return instance_;
  }

  void print()
  {
    cout << " hi hi hi " << endl;
  }

private:
  SingleTon(){}
  ~SingleTon(){}

  static SingleTon instance_;
};

struct Foo
{
};

SingleTon<Foo> SingleTon<Foo>::instance_;

int main()
{
    
  SingleTon<Foo>& s = SingleTon<Foo>::Instance();
  s.print();
  return 0;
}

[解决办法]

引用:

单例跟模板没关系吧

按照5楼的方式，就没有关系。
不过有时候程序中需要用到多个单例类的时候，就可以通过继承来实现，考虑到单例基类的静态方法，所以就要使用模板的编译期多态。
比如一个简单的例子

template<typename T>
class Singleton
{
public:
static T* Instance()
{
if(NULL == m_pInstance)
return  new T();

return m_pInstance;
}

static void Release()
{
if(m_pInstance  != NULL)
{
delete m_pInstance;
m_pInstance = NULL;
}
}

static T* m_pInstance;

protected:
Singleton(){}
~Singleton(){}
};
template<class T> T* Singleton<T>::m_pInstance = NULL;


//使用
class A : public Singleton<A>
{
protected:
friend class Singleton<A>;
A(){}

public:
~A(){}
void print()
{
cout << " hi hi hi " << endl;
}
};


int main()
{
A::Instance()->print();
A::Release();
return 0;
}

[解决办法]
我觉得继承的方法不好,因为可能会引入多继承, 可以用宏
下面这个不包含析构, 如果需要自行添加

#define SINGLETON(CT) /*单例模式*/\
private:\
CT ( void );\
CT ( const CT & );/*disallowed*/\
CT & operator= ( CT & );/*disallowed*/\
static CT *m_Instance; \
public:\
static CT *GetInstance ( void ) /*返回类的唯一实例的指针, 初次调用时调用构造函数*/\
{\
if ( m_Instance == NULL )\
m_Instance = new CT;\
return m_Instance;\
} 

[解决办法]

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

// Singleton 模式

#include "sync.h"
// #define NULL ((void *)0)

template <typename T>
class Singleton
{
private:
Singleton() {};      // ctor hidden 
 
Singleton (Singleton const&);// copy ctor hidden
Singleton & operator=( Singleton const&);// assign op. hidden
~ Singleton ();      // dtor hidden

static T* instance_;

public:
static T* Instance()
{
// double-check locking
if (instance_ == NULL)
{
static CSync sync;
sync.Lock();

if (instance_ == NULL)
instance_ = new T();

sync.Unlock();

}
return instance_;
}
};

template <typename T>
T* Singleton<T>::instance_ = NULL;

#endif // _SINGLETON_H_

[解决办法]
提供3种基于模板的实现。 顺便说一下，在程序中不要过渡使用单例或其变体（比如个全局变量）。

/*comments are welcome via email: bruceadi@hotmail.com*/

#include <cassert>

template< typename T>
T& instance()
{
   static T t;
   return t;
}

//or 

template<typename T>
class SingleonHolder
{
public:
    static T& instance()
{
   static SingleonHolder<T> inst;
   return inst.t;;
}
private:
 SingleonHolder(){}
 ~SingleonHolder(){}

 SingleonHolder(SingleonHolder const&); //forbidden copy construct
 SingleonHolder& operator= (SingleonHolder const&); //forbidden copy construct assignment

  T t;
};

//or 
template <typename Derived>
class SingleonBase
{
public:
    static Derived& instance()
{
   static Derived inst;
   return inst;
}
protected:
 SingleonBase() {}
 SingleonBase(SingleonBase const&); //forbidden copy construct
 SingleonBase& operator = (SingleonBase const&); //forbidden copy construct assignment
 ~SingleonBase(){}
};

struct Widget : public SingleonBase<Widget>
{
};

int main(int, char* args[])
{
   assert(&instance<int>() == &instance<int>());
   assert(&SingleonHolder<int>::instance() == &SingleonHolder<int>::instance());
   assert(&Widget::instance() == &Widget::instance());

   return 0;
}

[解决办法]

引用:

析构函数写成私有，这里给解释下，为什么写成私有吗，又没好处，写成私有岂不是要写另外释放单例对象的函数了吗?

构造函数/析构函数私有化是为了保证唯一性，只能通过全局入口生成实例，不能有其他方式生成实例。