Klassendefinitionen

[Kanonenfutter]

Ich hätte da folgendes Problem: Ich habe 2 Klassen die sich jeweils gegenseitig kennen müssen. In meinem Fall wäre das ein Parent und ein Child (in jeweils verschiedenen cpp Files):

// parent.h
class parent
{
     private:
          child* Child; // <-- braucht child-Definition
          
     public:
          parent();
};

// child.h
class child
{
     private:
          parent* Parent; // <-- braucht parent-Definition
          
     public:
          child();
};

Wie löst man so etwas am besten damit beide Klassen sich gegenseitig "kennen"?

 

[MCoder]

Wenn du die jeweils andere Klasse als Zeiger deklarierst, kannst du mit einer sogenannten Vorwärtsdeklaration arbeiten. Die CPPs brauchen aber dann auf jeden Fall das Include beider Klassen.

Gruß
MCoder

// parent.h

class Child;    // Vorwärtsdeklaration

class parent
{
     private:
          child* Child; // <-- braucht child-Definition
          
     public:
          parent();
};

// child.h

class Parent;    // Vorwärtsdeklaration

class child
{
     private:
          parent* Parent; // <-- braucht parent-Definition
          
     public:
          child();
};

 

[Kanonenfutter]

Ah sehr gut, Danke, habe mir schon so etwas in der Richtung gedacht, dies funktioniert ja auch bei Funktionen.
Wie könnte man so etwas lösen wenn die Eigenschaften nicht als Zeiger definiert wären? (nur so als Beispiel)

 

[jokey2]

Wenn Du jede Klassendefinition in eine eigene Headerdatei schreibst und die gegenseitig includierst (gegen Mehrfachincludierung schützen!) sollte das gehen.

 

[Kanonenfutter]

Gegenseitiges Inkludieren funktioniert da nicht wirklich. Ich seh das Problem immernoch darin, dass eine der beiden Klassen zuerst definiert sein muss, damit sie die andere kennt und umgekehrt...
Naja gut, das mit der Vorwärtsdeklaration funktioniert, bin zufrieden damit.

 

[jsendrow]

Ohne die Klassen insgesamt zu kennen (und das Problem das Du lösen willst) ist es schwer besserer Tipps zu geben. Eine Möglichkeit Dein Problem zu lösen wäre aber eine gemeinsame Oberklasse.

Könnte so aussehen:

// Sämtlicher Code den Parent und Child gemeinsam haben landet in der Oberklasse
class node {
private:
   node Node;

public:
   node();
};

// Parent-spezifischer Code hier
class parent : public node {
public:
   parent();
}

// Child-spezifischer Code hier
class child : public node {
public:
   child();
}

Und mal wieder meine pseudo-qualifizierten Style-Bemerkung zum Abschluß:

Ich finde es sehr unglücklich das Du Klassennamen kleinschreibst (class parent) und die Variablen dann Groß: (parent* Parent). Ich denke der allgemeine Usus genau umgekehrt: Klassen Großschreiben, Variablen davon klein. (Beispiel: C++, die Programmiersprache von Bjanre Stroustrupp, ok, doch ne Quelle). Das macht Deinen Code auf den ersten Blick spürbar unleserlicher.

 

[LukeS]

Eine Möglichkeit wäre auch jeweils die eine Klasse als Freund (friend) von der anderen zu deklarieren.

class Parent
{
       friend class Child;
....
};

class Child
{
       friend class Parent;
....
};

(bin mir wegen der friend-Syntax nicht ganz sicher)
Freundschaft ist nicht automatisch gegenseitig. Deshalb muss friend (wenn beidseitige Freundschaft erwünscht) in beiden Klassen daklariert werden.
Ich glaube friend wird von vielen Programmierern als schlechter Programmierstil angesehen und deshalb selten benuzt.

Gruss LukeS

 

[MCoder]

Eine Deklaration als "friend" bedeutet, dass Objekte der Friend-Klasse auch auf private Member zugreifen dürfen. Das hat mit der Problemstellung dieser Frage eigentlich nichts zu tun, da es hier darum ging Klassendeklarationen überhaupt erst mal gegenseitig bekannt zu machen.

Gruß
MCoder