template <typename BaseT>
class Singleton
    : public BaseT
    , private boost::noncopyable
{
private:
    Singleton()
    {
    }

    ~Singleton()
    {
    }

public:
    static Singleton& instance()
    {
        static Singleton _instance;
        return _instance;
    }
};

А>>template <typename BaseT>
А>>class Singleton
А>>    : public BaseT
А>>    , private boost::noncopyable
А>>{
А>>private:
А>>    Singleton()
А>>    {
А>>    }

А>>    ~Singleton()
А>>    {
А>>    }

А>>public:
А>>    static Singleton& instance(Singleton* p = 0)
А>>    {
           static std::auto_ptr<Singleton> _instance;
А>>        if (p) _instance.reset(p);
           else
           {
              if (!_instance) _instance.reset(new Singleton);
           }
А>>        return _instance.get();
А>>    }
А>>};
А>>

X& x = Singleton<X>::instance(new X(....));

const char * GetFileName ();

class Log
{
     public:
          Log ()
          {
               Open (GetFileName ());
          }
};

// это ваш исходный класс без конструктора по-умолчанию
class Logger
{
public:
  Logger(const std::string & name);
    ...
};

// добавим ему этот конструктор
class MyLogger
  : public Logger
{
  MyLogger(): Logger("c:/log.txt") {}
};

typedef Signleton<MyLogger> LogSingleton; // далее используем уже новый класс

template<class Face, class Impl=Base>
struct Singleton // а зачем Singleton наследовать от базы - я не понимаю
{
    static Face& instance()
    {
        Impl impl;
        return impl;
    }
};

struct Foo
{
    Foo(Bar);
};

struct FooDerived : Foo
{
    FooDerived() : Foo(make_bar()) {}
};

struct FooProxy : noncopyable
{
    auto_ptr<Foo> foo;
    FooProxy()
    {
        Bar bar;
        bar.init();
        .....
        foo = new Foo(bar);
        .....
    }
    operator Foo&() { return *foo; }
};

template<class Obj, class CreationPolicy=DefaultCreationPolicy<Obj> >
struct Singleton
{
    static Obj& instance()
    {
        Obj& ref = Policy::make_object();
        // при желании, здесь можно сделать потокобезопасный код с двойной проверкой
        // и прочую обвеску
        
        return ref;
    }
};
template<class Obj>
struct DefaultCreationPolicy
{
    static Obj make_obj() { return Obj(); }
};


struct FooPolicy1 // фабрика объектов
{
    static Foo make_object() { ..... return Foo(bar); }
};
struct FooPolicy2 // фактически, тот же синглетон Мейерса - только в самом простом его исполнении
{
    static Foo& make_object() { ..... static Foo foo(bar); return foo; }
};

struct FooPolicy
{
    static int x, y, z; // должны быть установлены до первого вызова instance
    static Foo make_object() { return Foo(Bar(x,y,z)); }
};

А>template <typename BaseT>
А>class Singleton
А>    : public BaseT
А>    , private boost::noncopyable
А>{
А>private:
А>    Singleton()
А>    {
А>    }

А>    ~Singleton()
А>    {
А>    }

А>public:
А>    static Singleton& instance()
А>    {
А>        static Singleton _instance;
А>        return _instance;
А>    }
А>};
А>

А>Решение с передачей аргументов в функцию instance выглядит не очень красивым, так как синглтон создается одни раз по определению, дык что теперь при каждом вызове эти аргументы передавать...

  //  singleton
template <class T>
class single
{
protected:
  single()
  {}

  ~single()
  {}

  typedef single<T> self_single;
  typedef T self;

public:
  static T & get_single(); // получить экземплярчик
};

template <class T>
inline T & single<T>::get_single()
{
  static T instance;
  return instance;
}

  //  применение singleton'а на этом классе
class something :
  public single<something>
{
  friend class self_single;
private:
  int i;
  something(int new_i) : i(new_i)
  {}

  ~something()
  {}
};

  //  полная специализация метода
template <>
inline something & something::self_single::get_single()
{
  static self instance(10); // параметры
  return instance;
}