typedef void(*my_atexit_fn)(void*);

void schedule_my_atexit(my_atexit_fn fn, void* param); // добавляет функцию в начало списка
void perform_my_atexit(); // вызывает все, что было спланировано

template<class T>
class single_holder
{
  friend class single_ptr<T>;

  void addref();
  void release();
  T* take();
  ... all implementation ...
public:
  static single_ptr instance() { return single_ptr(); } // этот метод - дань стилю
};

template<class T>
class single_ptr
{
  typedef single_holder<T> holder;
public:
  single_ptr() { return holder::addref(); }
  single_ptr(const single_ptr&) { return holder::addref(); }
  ~single_ptr() { return holder::release(); }

  operator T*() const { return holder::take(); }
  T* operator->() const { return holder::take(); }
};

class my_single
{
  friend class single_holder<my_single>;

  my_single(const my_single&);

protected: // если допускаем существование наследников
  my_single() { . . . }
  ~my_single() { . . . }

public:
  . . .
};

class Object:public Singleton<Object>
{
..
private:
   virtual void OnCreate();
..
}


//теперь наследование от класса Object:
class MyObject:public Object
{
..
private:
   MyObject(){}
   virtual void OnCreate()
   {
      MessageBeep(1);
   }
..
}
//проверяем:
MyObject *obj=(MyObject*)MyObject::Instance();
obj->OnCreate(); //не заходит в MyObject

class SinglImpl: public Singleton
{
protected:
  SinglImpl(){}
  //объявление виртуальным в базовом классе автоматически 
  //дает виртуальность в производном.
  ~SinglImpl() { printf ("~SinglImpl\n"); }
public:
  static Singleton* Instance()
  {
    if(!_self) _self = new SinglImpl();
    _refcount++;
    return _self;
  }
};

template <class _Key, class _Value, class _KeyOfValue, 
          class _Compare, class _Alloc> void 
_Rb_tree<_Key,_Value,_KeyOfValue,
  _Compare,_Alloc>::_M_erase(_Rb_tree_node<_Value>* __x)
{
                                // erase without rebalancing
  while (__x != 0) {
    _M_erase(_S_right(__x));
    _Link_type __y = _S_left(__x);
    _Destroy(&__x->_M_value_field);
    this->_M_header.deallocate(__x,1);
    __x = __y;
  }
}

template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
void RbTree <Key, Value, KeyOfValue, Compare, Alloc> :: Erase(RbTreeNode<Value>* x)
{
                                // erase without rebalancing
  while (x != 0) {
    
    Erase( Right(x) );

    LinkType y = Left(x);
    Destroy( &x->ValueField );
        
    this->Header.deallocate(x, 1);

    x = y;

  }
}

template <class T>
class Singleton
{
  static T* _self;
  static int _refcount;
protected:
  Singleton(){}
  virtual ~Singleton(){_self=NULL;} // Здесь _self не удаляется
public:
  static T* Instance();
  void FreeInst();
};

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

template <class T>
int  Singleton<T>::_refcount=0;

template <class T>
T*  Singleton<T>::Instance()
{
  if(!_self)
    _self=new T;  // Здесь создается объект типа T
  _refcount++;
  return _self;
}

template <class T>
void  Singleton<T>::FreeInst()
{
  if(--_refcount==0)
    delete this;  
    //Почему delete this; ? создавался ведь объект типа T. На мой взгляд delete _self нужно;

}

#include <memory>

class Singleton {
private:
  static std::auto_ptr<Singleton> instance;

public:
  static Singleton* getInstance();

};

#include "Singleton.h"

std::auto_ptr<Singleton> Singleton::instance; // Инициализируется нулем

Singleton* Singleton::getInstance() {
  if( !instance.get() ) {
    instance = std::auto_ptr<Singleton>(new Singleton());
  }
  return instance.get();
}

template<typename T> class single_ptr;

template<class T> class single_holder {
private:
    static T* _self;
    static int _refcount;
    friend class single_ptr<T>;

    void addref()  {_refcount++;}
    void release();
    T* take();
public:
    //static single_ptr instance() { return single_ptr(); } /*А ЧТО ЗДЕСЬ???*/
};

template<class T> T* single_holder<T>::_self = 0;
template<class T> int single_holder<T>::_refcount = 0;

template<class T>
T* single_holder<T>::take() {
    if(!_self) {
        _self = new T;
    }
    return _self;
}

template<class T>
void single_holder<T>::release() {
    if(--_refcount == 0) {
        delete _self;
    }
}

template<class T>
class single_ptr
{
  typedef single_holder<T> holder;
public:
  single_ptr() { holder::addref(); }
  single_ptr(const single_ptr&) { holder::addref(); }
  ~single_ptr() { holder::release(); }

  operator T*() const { return holder::take(); }
  T* operator->() const { return holder::take(); }
};