Klassendefinitionen

alfredQ

Stimmt beides

Wenn ich aber jetzt einen Zeiger verwende:

#ifndef SpeicherH
#define SpeicherH

#include "Character_ccl.h"
#include "Character_player.h"
#include "Character_gegner.h"
#include "kartenelement.h"

class Memory
{
...

cl_kartenelement* zeiger;

...

kommt "E2303: Typname erwartet". Dabei ist doch cl_kartenelement in kartenelement.h definiert. Was hab ich nu wieder falsch gemacht?
Danke, Alfred

Alexander Kempf

Vermutlich hilft Dir hier eine Forward-Deklaration.

Gruß,

Alexander

alfredQ

#include "kartenelement.h"

class Memory
{
...

class cl_Kartenelement;
cl_kartenelement* zeiger;

...

Nicht wirklich, wenn ich diesen Pointer benutze kommt der Fehler " Undefinierte Struktur 'Kl_GlobalMemory::cl_Kartenelement'" und "Größe des Typs 'Kl_GlobalMemory::cl_Kartenelement' unbekannt oder Null"?
Alfred

Alexander Kempf

Also, ich nehme den include dann immer in die cpp-Datei rein.
Es würde mich mal interessieren, ob das guter oder schlechter Stil ist,
aber es funktioniert auf jeden Fall.

Gruß,

Alexander

alfredQ

In welche cpp-datei meinst du? einen Include brauch ich aber auf jeden fall in der Headerdatei von Memory. Dort hab ich einen Zeiger auf cl_kartenelement ( für dyn. array ). der fehler kommt in der ersten anderen klasse, die auf dieses zugreift. in kartenelement wird cl_kartenelement definiert. ich hab beide header in die klasse, die den fehler bringt, eingebunden, aber ohne erfolg.

Alexander Kempf

alfredQ schrieb:

Dort hab ich einen Zeiger auf cl_kartenelement ( für dyn. array ).

Ist das eine globale Variable?
Vielleicht zeigst Du mal noch ein bißchen mehr Quelltext, aus dem ersichtlich wird,
welche Header sich jeweils per include einbinden.

Gruß,

Alexander

alfredQ

Stimmt, ich erklärs mal ordentlich. Im Prinzip ist das so:

Header1.h:

#ifndef Header1H
#define Header1H

class KlasseA
{
  public:
  char element;
};
#endif

Header2.h:

#ifndef Header2H
#define Header2H

#include "Header1.h"

class KlasseB
{
  public:
  KlasseA* zeiger;  
};
#endif

Code.cpp:

#include "Header2.h"

void CodeKlasse::machen()
{
  KlasseB B;
  B.zeiger = new KlasseA[ 5 ];
};

So soll es funktionieren.
Aber es kommt der Fehler Typname erwartet. Daher habe ich folgendes gemacht:

class KlasseB
{
  public:
  class KlasseA;
  KlasseA* zeiger;  
};

Jetzt kommt aber in Code.cpp die Fehler "Undefinierte Struktur 'KlasseB::KlasseA'" und "Größe des Typs KlasseA::KlasseB' unbekannt oder Null".
Auch wenn ich in Code.cpp Header1 noch einbinde ändert sich nichts.

Alexander Kempf

Wie sieht denn die Header-Datei zu Code.cpp aus?

alfredQ schrieb:

Code.cpp:

#include "Header2.h"

void CodeKlasse::machen()
{
  KlasseB B;
  B.zeiger = new KlasseA[ 5 ];
};

alfredQ schrieb:

Daher habe ich folgendes gemacht:
class KlasseB
{
  public:
  class KlasseA;
  KlasseA* zeiger;  
};

Ich hätte die Forward-Deklaration außerhalb der Klassen-Deklaration von KlasseB eingefügt:

class KlasseA;  // Forward-Deklaration

class KlasseB
{
  public:
  KlasseA* zeiger;  
};

Wahrscheinlich bekommst Du damit aber nur eine andere Fehlermeldung.

Gruß,

Alexander

alfredQ

Du hattest den Finger drauf!
Die Forward-Deklaration hab ich jetzt aus der Klassen-Deklaration von KlasseB rausgezogen und es funktioniert!
Kann das jmd. mit OOP-argumenten ein bischen erklären? Es hätte eigentlich auch so gehen sollen.
Danke, Alfred

Dasd

Soweit ich weiß, kannst du nicht einfach innerhalb einer Typdefinition (class) eine weitere Typdefinition anbringen. Denn damit erzeugst du ja wieder einen neuen Typ, was dir der compiler dann auch ankreidet (Er hält "KlasseA::KlasseB" für einen neuen Typ). Mit dem Forwarden außerhalb der Klasse sagst du dann bescheid, dass es eine Klasse mit diesem Namen gibt. Damit ist diese dann in deiner eigentlichen Klasse bekannt.

dschensky

AlfredQ,

alfredQ schrieb:

Kann das jmd. mit OOP-argumenten ein bischen erklären? Es hätte eigentlich auch so gehen sollen.

tut es auch - ohne forward-Deklaration. Ich habe das Beispiel sicherheitshalber ausprobiert (CB4). Im Grunde ist es eine einfache Sache: code.cpp inkludiert Header2.h, welche Header1.h inkludiert. Das hat mit OOP nicht wirklich etwas zu tun.

Dasd schrieb:

Soweit ich weiß, kannst du nicht einfach innerhalb einer Typdefinition (class) eine weitere Typdefinition anbringen.

Also prinzipiell geht das (Stichwort "Elementklasse"):

class A
{
public:
  class B
  {
  public:
    void foo();
  };
};

void A::B::foo()
{
}
...
A::B b;
b.foo();

Allerdings wüßte ich gerade nicht, wo man das sinnvoll einsetzen könnte ...