template<typename _Type>
inline static foo* instance() { static std::auto_ptr<foo> _inst(new _Type); return _inst.get(); }

Das das so nicht geht ... ist klar Die Instanz ist nicht einmalig, was aber gegeben sein muss. Dann kommt noch hinzu, dass ich beim ersten Aufruf, d.h. wenn die static-Variable belegt wird, einen Parameter übergeben muss:

template<typename _Type>
inline static foo* instance(bar const& param1) { static std::auto_ptr<foo> _inst(new _Type(param1)); return _inst.get(); }

Hat da jemand eine Idee wie man das realisieren könnte?

Aber eigentlich hast du es schon fast richtig:

template<typename Type>
class Singleton
{
  static Type* instance() { static std::auto_ptr<Type> _inst(new Type); return _inst.get(); }
};

Die abgeleitete Klasse erzeugst du dann einfach so:

class Test : public Singleton<Test>
{
};

Und einen Parameter würde ich an dieser Stelle nicht übergeben, weil dann müßtest du den ja überall beim Zugriff angeben.
Du solltest dann lieber im Default-Konstruktor der abgeleiteten Klasse auf einen Parameter zugreifen, den du halt z.B. als statischen Member bereitstellst.

class Test : public Singleton<Test>
{
  static int m_initparam;
public:
  static int SetInitParam(int param) { m_initparam = param; }

  Test()
  {
    // use m_initparam
  }
};

ich bin mir nicht ganz sicher, was das soll. Wozu z.B. der Auto-Ptr? Wozu das Template (das sollte eher ein Klassen-Template, kein Funktionstemplate sein, oder)?

Das einzige Problem ist die Parameter-Initialisierung. Hierzu musst Du dann doch einen Auto-Ptr verwenden und delayed intialization verwenden, in Verbindung mit der Init-Funktion von Th.

ich fand das ganz interessant, deswegen habe ich mal was ausprobiert. Klappt eigentlich genauso, wie ich mir das dachte. Hast Du das so gemeint?

#include <memory>
#include <iostream>

template <typename D>
struct custom_singleton {
    static D* instance() {
        return m__instance.get();
    }

protected:
    custom_singleton() { }
    custom_singleton(custom_singleton const&);
    custom_singleton& operator =(custom_singleton const&);

    static void init(D* inst) {
        m__instance = static_cast< std::auto_ptr<D> >(inst);
    }

private:
    static std::auto_ptr<D> m__instance;
};

template <typename D>
std::auto_ptr<D> custom_singleton<D>::m__instance;

struct derived : public custom_singleton<derived> {
    static void init(int var) {
        custom_singleton<derived>::init(new derived(var));
    }

    void print() const {
        std::cout << "derived.m_var: " << m_var << std::endl;
    }

private:
    derived(int var) : m_var(var) { }

    int m_var;
};

int main() {
    derived::init(42);
    derived* d = derived::instance();
    std::cout << "Address of d: " << d << std::endl;
    d->print();
}

Wobei ich eine Referenz als Rückgabewert schon besser fände als einen Zeiger.

Hmm ja das Problem ist jetzt aber, dass ich auch will, dass ich jetzt hingehen kann, nachdem ich einmal die Funktion aufgerufen habe und der Typ gesetzt ist, ich die Funktion aufrufen kann (mit foo als Type) und der mir dennoch die richtige Instanz zurück gibt. Aber stimmt so nicht, würd was anderes auskommen.

Hm, das verstehe ich jetzt nicht. Die Funktion ist ja jetzt gar kein Template mehr, Du kannst natürlich aber mehrere Klassen ableiten und das ganze z.B. auch für den Typ 'foo' tun:

struct foo : custom_singleton<foo> {
    using custom_singleton<foo>::init;
};

// …

foo::init(new foo());
foo::instance();
// Oder, genauso:
custom_singleton<foo>::instance();