Zugriff von Klasse auf Klasse die von sich erbt?!

najjannaj

Hallo,
ich habe folgendes dringendes Problem:

Ich habe eine Klasse "Node"

class Node {
.
.
.
}

und eine Klasse "Leaf"
#include "Node.h"
class Leaf {
.
.
.
}

jetzt habe ich in der Node eine Funktion in der ich einen Node-Pointer auf einen Leaf-Pointer wechseln kann.

Leaf* lptr = reinterpret_cast<Leaf*> (ptr);

Dies funktioniert außerhalb vom Node perfekt. In der Node-Klasse behauptet er das er Leaf nicht kennt und nichts damit anzufangen weiß.. wenn ich in der Node jedoch "include "leaf.h" mache.. bekomm ich tausend fehler, ich denke das ich nichts includen kann das von mir selbst erbt oder? Hat da jemand eine Lösung!
Wäre Prima!

VIELEN DANK!
Mit freundlichen Grüße
najjannaj

Kuldren

Such mal nach "Zirkuläre Abhängigkeit"

najjannaj

Danke, wenn man weiß wie sein Problem heißt lässt sich doch leichter eine Lösung finden

hustbaer

reinterpret_cast ist an der Stelle Blödsinn, static_cast wäre angebracht.

asc

najjannaj schrieb:

ich habe folgendes dringendes Problem:

Wobei ich hier ohnehin von einigen Designfehlern ausgehe.

1. Includeguards verwenden

// a.h
#ifndef A_HEADER
#define A_HEADER
//      <------> Includeguard, muss eindeutig pro Header benannt werden.

class A
{
    public:
        void foo(); // Verwende ich im Schritt 3
};

#endif

2. Verwende den Header soweit möglich nur zur Deklaration, das erleichtert dir den 3. Schritt

3. Zirkuläre Abhängigkeiten sind aufzulösen
Du darfst keine zirkulären Abhängigkeiten in Headern haben. Ein gegenseitiges Includieren von Headern ist nicht möglich. Was möglich ist, ist das man Includes durch Vorwärtsdeklarationen (Geht für Zeigertypen und Referenzen) in die Sourcedatei verlagert.

Beispiel:

// b.h
#ifndef B_HEADER
#define B_HEADER

class A; // Vorwärtsdeklaration

class B
{
    public:
        // Folgendes ist möglich, da für Referenzen/Zeiger kein vollständiger
        // Typ bekannt sein muß. Erst für den Zugriff (hier z.B. value.foo()) 
        void foo(A const & value);
};

#endif

// b.cpp
#include "b.h"
#include "a.h" // Da ein Zugriff erfolgt, muss nun der Header bekannt sein

void B::foo(A const & value)
{
    value.foo();
}

4. Casten von Inkompatiblen Typen
Ich hoffe du bist dir wirklich bewusst was passiert wenn du zwei inkompatible Typen ineinander umwandelst? Sind die Speicherlayouts beider Klassen wirklich kompatibel? Liegen die Elemente an gleicher Stelle?

Ich glaube du solltest dir eher mal Vererbung (inklusive virtuellen Funktionen) und dynamic_cast anschauen.

cu André

hustbaer

Huch!
Ich bin einfach davon ausgegangen dass hier bei "Leaf" ein ": public Node" fehlte

Wenn nicht ... ist es sowieso quatsch wie asc ja gerade schon geschrieben hat!