template <class T>
T*  Singleton<T>::Instance()
{
  if(!_self)
  {
    _self=new T;
    _refcount++; // вот это
  }
  _refcount++;
  return _self;
}

template<class T>
class TSingeltonPtr
{
  T *_t;
public:
  TSingeltonPtr() { _t = T::Instance(); }
  ~TSingeltonPtr() { if(_t) _t->FreeInst(); }
  operator T*() { return _t; }
  T* operator->() { return _t; }
  bool operator!() const { return _t==0; }
};

class Derived : public Singleton<Derived>
{
void foo();
...
};
void bar()
{
  TSingeltonPtr<Derived> sp;
  if ( !sp ) return;
  sp->foo();
}

namespace myinterface
{

bool Start();
bool Stop();

bool DoAction();

}

include "myinterface.h"

static struct __Switcher
{
     __Switcher() { constructor(); }
    ~__Switcher() { destructor(); }

} theSwitcher;


static int* InterfaceData;

static void constructor()
{
    InterfaceData = new int(0);
}

static void destructor()
{
    delete InterfaceData;
}

bool myinterface::Start()
{
   //здесь можно принять какието параметры из вне
   //так же можно проверить если другие неоходимые интерфесы 
   //уже запущенны, проинициализированны
}

bool myinterface::Stop()
{
   //(для примера) Мне требовалась остановка потоков без прекращения работы программы
}

bool myinterface::DoAction()
{
    printf( "Hallo from do_action [%d]", InterfaceData++ );
}

struct theT 
{
    static T& Instance () {
        static T self;  // здесь можно провести инициализацию связки стат. объектов.
                        // для этого удобно использовать конструктор локального
                        // класса, статическая переменная которого определяется
                        // в этом методе
        return self;
    }
};

{
   if (Derived::Instance()->IsReadyToSetCounter())
   {
      Derived::Instance()->SetSomeCouner(
         Derived::Instance()->GetSomeCouner() +1);
   }
}

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(); }
};