#if !defined(_TERMINAL_H)
#define _TERMINAL_H

//#include "Schranke.hpp"
//#include "Anzeige.hpp"
#include "Platz.hpp"
#include "Karte.hpp"
#include "Student.hpp"
#include "WinGrafik.hpp"
#include "Einfahrttest.hpp"

class Terminal
{
private:
	int MatrNr;
	//Anzeige *freiPlatz;
	Platz *pzaehlen;
	Karte *KarteObj;
	Student *StudentObj;
	Einfahrttest *freiPlatz,*guelt;
    WinGrafik* gk;

public:
	Terminal(WinGrafik* gk);
	void ueberpruefenPlatz();
	void empfangenMatNr(int MatrNr);
	void empfangenPlatz(int n);
	//Schranke *oeffnen;
};

#endif  //_TERMINAL_H

seht ihr da schon einen Fehler? Wenn nicht sagt mir was ich noch braucht.
Ich hoff ihr könnt mir helfen!

mfg

soll das nicht eher

#ifndef _TERMINAL_H

sein?

sind die anderen includierten header ok? bei jeder klasse ein }; vorhanden? vergisst man gerne und man bekommt die merkwürdigsten fehler..

ist vollkommen i.o. nur _### nicht ...

#if !defined(_TERMINAL_H)
#define _TERMINAL_H

kein Problem sein. Oder?
(D)Evil wie meinst du das mit "_###"?

und ja die Header binden Teils auch diesen ein.

Dann ist das dein Problem. Zirkuläre Abhängigkeiten von Definitionen sind in C++ nicht darstellbar. Und auch der Inludeguard hilft da nicht, und das ist auch nicht der Zweck desselben. [Anm. (D)Evil: ein bisschen mißglückt ist das schon: einerseits auf standardkonformer Reservierung von Bezeichnern bestehen - wobei klar ist, dass das hier nicht die Ursache des Problems ist - andererseits #pragmas einführen, die definitionsgemäß plattformabhängiges Verhalten haben].

Grundsätzlich muss es eine klare Hierarchie von Headern geben, ein Header1 der einen Header2 einbindet, darf nicht (direkt oder indirekt) von Header2 selbst wieder eingebunden werden [Ausnahmen bestätigen die Regel und sind zu speziell, um hier diskutiert zu werden].

Kleines Beispiel:
header1

#ifndef HEADER1
#define HEADER1
#include "header2"
class X
{
    Y* p;
};
#endif

header2

#ifndef HEADER2
#define HEADER2
#include "header1"
class Y
{
    X* q;
};
#endif

main.cpp

#include "header1"

Was passiert hier:
1. main.cpp bindet header1 ein
2. der Präprozessor trifft auf die ifndef Direktive, da das Symbol HEADER1 noch nicht definiert ist, wird der folgende Teil des Headers eingebunden
3. Das Symbol HEADER1 wird definiert
4. der Präprozessor trifft auf das #include "header2" und macht mit dieser Datei weiter
5. der Präprozessor trifft auf die ifndef Direktive, da das Symbol HEADER2 noch nicht definiert ist, wird der folgende Teil des Headers eingebunden
6. Das Symbol HEADER2 wird definiert
7. der Präprozessor trifft auf das #include "header1" und macht mit dieser Datei weiter
8. der Präprozessor trifft auf die ifndef Direktive, da das Symbol HEADER1 bereits definiert ist, wird der folgende Teil des Headers nicht eingebunden, folglich auch die Definition von Class X übersprungen
9. der Präprozessor kehrt zur Bearbeitung von Header2 zurück (7) und bindet diesen ein, darin enthalten ist die Definition von Y
10.der Präprozessor kehrt zur Bearbeitung von Header1 zurück (4) und bindet diesen ein, darin enthalten ist die Definition von X

so sieht das ergebnis des Präprozessordurchlaufs aus:

class Y
{
    X* q;
};
class X
{
    Y* p;
};

Und es ist ganz klar, dass der Compiler sich hier in der Definition von Y über einen unbekannten Bezeichner "X" beschweren wird. In diesem speziellen Fall wollen wir aber nur einen Zeiger deklarieren. Ein Zeiger ist auch dann ein vollständiger Typ, wenn der Typ, auf den gezeigt wird, es nicht ist. Wir benötigen daher nur eine Deklaration von X, nicht die Definition des selben (und eine solche Deklaration nennt man für gewöhnlich Vorwärtsdeklaration):

class X;

genügt, um die Klasse Y definieren zu können. So sollte unser sinnfreies Beispiel also aussehen:header1

#ifndef HEADER1
#define HEADER1
class Y;
class X
{
    Y* p;
};
#endif

header2

#ifndef HEADER2
#define HEADER2
class X;
class Y
{
    X* q;
};
#endif

unser main.cpp müsste dann natürlich beide Header explizit einbinden, um beide Definitionen nutzen zu können.