#if !defined (RC_SINGLETON_H__INCLUDED)
#define RC_SINGLETON_H__INCLUDED

#if (_MSC_VER > 1000)
#pragma once
#endif

namespace realcay
{
    template <class T>
    class RCWINDOW_API Singleton
    {
    public:
        inline static T& instance() { static T inst; return inst; }

    protected:
        Singleton();

        public:
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    };
};
#endif // RC_SINGLETON_H__INCLUDED

ist mein Singleton. Dieser liegt in einer DLL ...

Jetzt habe ich eine Klasse ... nennen wir sie "base", die unter anderem folgende Funktionen (oder so ähnlich ;)) drin hat:

#include <map>
#define AE_RENDER 1
#define AE_USER 11

class base : public realcay::Singleton<base>
{
    typedef void (base::*EventHandler)(const void*);

private:
    std::map<std::size_t, EventHandler> m_Hndls;

public:
    void send_message(std::size_t id, const void* data)
    {
        std::map<std::size_t, EventHandler>::iterator it = m_Hndls.find(id);
        if (it != m_Hndls.end()) (*this.*it->second)(data);
    }
    void register_message(std::size_t id, EventHandler hdnl)
    { m_Hndls[id] = hdnl; }
};

Soweit ist ja alles selbsterklärend ... oder? Man kann halt ein Event registrieren (register_message), AE_RENDER usw., und wenn man dann base::instance().send_message aufruft, wird gegebenen Falls die Funktion die registriert wurde, aufgerufen.

Nun sieht man ja an der definition von EventHandler, dass es eine von base abgeleitete Klasse sein muss, um eine Memberfunktion derer problemlos in
einen EventHandler casten zu können. Also kommt eine Klasse derived ins Spiel:

class derived : public base
{
public:
     derived() : m_int(0) { register_message(AE_RENDER, &derived::on_render); }

private:
     void on_render(const void* data) { std::cout << m_int << std::endl; }

private:
    int m_int;
};

Jetzt hab ich aber ein Problem mit instance(), da diese Funktion ja ein Objekt von base erstellt, ein derived-Objekt wird aber nie erstellt! Gerade das ist aber von nöten.

Nun könnte ich ja bsw. hingehen und aus base ebenfalls eine template-Klasse machen ... geht aber nicht, da ich in der DLL die Klasse base schon nutze und da ist mir der Name von der abgeleiteten Klasse noch nicht bekannt!
Wie könnte man das Problem umgehen? Hat jemand eine Idee?

a) du packst alles was du in derived hast gleich in base rein, wenn du eh keine weitere Klasse von base ableien willst.

b) du machst derived zum Singleton an Stelle von base. Stichwort mehrfache Vererbung. Dann kannst du mehrere abgeleitete Singletons und nicht-singletons haben, die das Verhalten von base erben

c) wenn du tatsächlich ein globales Singleton Objekt benötigst, das aber je nach Umgebungsbedingungen verschiedene Ausprägungen haben soll, dann werden diese verschiedenen Ausprägungen ja alle das selbe Interface haben. dann sollte dein Singleton nur das Interface zur Verfügung stellen und alles andere einem Implementierungs-Objekt überlassen, das du ihm zur Laufzeit gibst.

a) Fällt raus, da es unterschiedliche Teilprogramme sind. Die DLL ist nur das Interface ...
b) Fällt raus ... s.o.
c) wie du meine?

Nja werd sonnst in dem Singleton einfach nur einen Pointer speichern, den man dann am Anfang initialisieren muss ... d.h.

class base
{
    typedef void (base::*EventHandler)(const void*);

private:
    std::map<std::size_t, EventHandler> m_Hndls;

public:
    void send_message(std::size_t id, const void* data)
    {
        std::map<std::size_t, EventHandler>::iterator it = m_Hndls.find(id);
        if (it != m_Hndls.end()) (*this.*it->second)(data);
    }
    void register_message(std::size_t id, EventHandler hdnl)
    { m_Hndls[id] = hdnl; }

public:
    inline static base* instance(base* ptr = NULL) { static base* inst = ptr; return inst; }
};

...

int main()
{
    derived inst;
    derived::instance(&inst);
}

oder so ähnlich ...
nen besserne Vorschlag?

Ausserdem, wozu du dir die Muehe machst einen operator= zu schreiben fuer einen Singleton, entzieht sich auch meinem Verstaendnis (gilt auch fuer den Copy-Constr.).

Ausserdem, wozu du dir die Muehe machst einen operator= zu schreiben fuer einen Singleton, entzieht sich auch meinem Verstaendnis (gilt auch fuer den Copy-Constr.).

damit man se nciht nutzen kann setz ich se privat ...

Was ich mit c) ausdruecken wollte: Wenn du dem Klienten die Moeglichkeit geben willst, gewisse Features zu Base hinzuzufuegen, kannst du in base dafuer eine Schnittstelle anbieten, allerdings ist der KLient dann daruf beschraenkt. Bsp:

class base : public singleton<base>
{
public:
  void changeimpl(baseImpl* newimpl) {delete impl; impl = newimpl;}

  void ichweisswas1() {cout << "ich weiss was 1" << endl;}

  //schnittstelle fuer klient:
  void weissnich1() {imol->weissnich1();} 
  void weissnich2() {impl->weissnich2();}
private:
  baseImpl* impl;
  base() : impl(0) {};
  ~base() {delete impl;}
};

class baseImpl 
{
  virtual void weissnich1() = 0;
  virtual void weissnich2() = 0;
}

So kann der Klient mit changeimpl seine eigene Version der Schnittstelle "weissnich" in die base klasse "injizieren", ohne deren Singleton Eigenschaft aufzubrechen