Klassen-Struktur-Frage

Hi!

Ich hab mal ein Frage, wie man folgendes Problem möglichst elegant löst:

- Ich hab ein zentrales Interface (es sei mal dahingestellt welches), dass ich durch die Klasse A repräsentiere, die einen Zeiger auf dieses Interface hat
- Ich habe mehrere Unterstützer-Klassen B, C, ..., die das Intercace bzw. einen Verweis auf die Klasse A brauchen

Mein Problem ist jetzt, dass der Nutzer der Klassen ja jetzt z.B. Klasse B nutzen kann, wenn A schon längst deinitialisiert ist, was zu einem Fehler führen würde, da der Pointer, der von B zu A zeigt nicht mehr gültig ist.

Ich kann B auch keine Kopie von A übergeben, da das die Performance bei diesem Interface zu weit in den Keller treiben würde.

Habt ihr eine Lösung für das Problem???

Würde mich über Antworten freuen...

MfG,

EnERgYzEr

kannst du deine klassen nicht das interface erben lassen ?

was auch immer

energyzer

Es handelt sich um DirectX, dass kann ich nicht vererben.

Vielleicht kann ich ja jetzt auch noch mal die Sache verdeutlichen:

Ich hab eine Haupt-Klasse, die die DirectX Hauptfunktionalitäten repräsentiert. Und weitere Klassen, die z.B. eine Textur repräsentieren. Diese Textur-Klasse braucht aber einen Verweis auf die Haupt-Klasse...

Sollte jetzt aber jmd. auf die Idee kommen die Textur Klasse zu nutzen während die Haupt-Klasse schon gelöscht wurde gibt es ein Problem

Es muss doch für so ein Standard-Problem eine Lösung geben, oder?

wenn du in deiner derived klasse pointer auf die base hast, kannst du immer bevor du den pointer auf die base benutzt pruefen ob er 0 ist. falls das der fall ist must du ihm mit new wieder was auf dem freestore freimachen, ansonsten einfach weitermachen.

was auch immer

energyzer

derived = vererbt, oder?

die klassen sind allerdings nicht vererbt.

aber wenn ich das mit dem null-checken machen würde, müsste der pointer auf die haupt-klasse immer auf NULL gesetzt werden nachdem sie gelöscht wurde. das gehört sich natürlich so, aber man kann ja leider nicht davon ausgehen, dass das jeder so macht.

gibt es nicht noch eine andere lösung für das problem??? also entweder eine methode um 100%ig zu prüfen ob ein pointer auf eine klasse noch gültig ist oder eine methode, die verhindert, dass er jemals in der hilfs-klasse ungültig wird.

HumeSikkins

Hallo,
wie wäre es denn mit Referenzzählung?

energyzer

HumeSikkins schrieb:

Hallo,
wie wäre es denn mit Referenzzählung?

hab mal ein bisschen mich zu dem thema umgesehen und selbst noch mal drüber nachgedacht - bin dann auf folgende lösung gekommen:

- ich hab in der Haupt-Klasse eine static-Variable, die die Anzahl der Instanzen zählt

- außerdem gibt es eine static-Methode, die überprüft, ob es eine Instanz gibt woraufhin diese zurückgegeben wird oder gegebenenfalls eine neue instanz erzeugt wird

würde diese idee soweit funktionieren? wäre das sauber?

vom code her hatte ich mir das so vorgestellt:

class HauptKlasse
{
    public:
        static bool bInstanz;
        static HauptKlasse* pInstanz;

        static *HauptKlasse IfValid
        {
            if(bInstanz)
                return pInstanz
            else
                return new HauptKlasse();
        }

        HauptKlasse
        {
             if(bInstanz)
                  return *pInstanz;
             else
             {
                 bInstanz = true;
                 pInstanz = this;
                 return *this;
             }
         }

         ~HauptKlasse
         {
             bInstanz = false;
         }

         static void Clear
         {
             if(bInstanz)
                 delete pInstanz;
         }
}

das klappt doch nie, oder?????

mac_bu

Folgende Methode ist zwar nicht die komfortabelste, aber zuverlässig:

Bei jedem Aufruf einer Prozedur der Klassen B,C,D ..., die auf A arbeitet, übergibst du einen Pointer auf eine Instanz der Klasse A.