1. Design überdenken
2. Design überdenken
3. Design überdenken
4. Forward-Declarations (-> ggf. Google)

sind dass die einzigen möglichkeiten?

Bzw Dependency Injection. Ist aber beides Javalike und ich kanns beides nicht untereinander auseinander halten.

Der "Trick" ist halt, dass du nicht gegen was konkretes programmierst, sondern nur gegen die öffentlichen Schnittstellen.

Und wenn die Klassen sich dann noch gegenseitig brauchen, musst du halt Forward-Declarations benutzen.

Beispiel:

"Test.h":

class Test
{
};

"Foo.h":

#include "Test.h"

class Foo
{
};

Der Präprozessor macht aus "Foo.h" dann

class Test
{
};

class Foo
{
};

edit:

WhileTrueDo schrieb:

ich glaube das einfachte ist einfach eine map/player.h zu machen danke für deine hilfe

wenn du damit meinst, dass du beide Klassendeklarationen in ein Headerdatei schrieben willst, ist das so ziemlich das dämlichste, was du in der Situation machen kannst

Ohne forward-Deklaration wirst du mit dem Ansatz übrigens auch scheitern...

// Player.cpp
#include "Player.h"
#include "Map.h"

void Player::foo(Map & m)
{
  m.bar(*this);
}

//Map.h
#pragma once

class Player; // Forward Declaration

class Map
{
public:
  void bar(Player & p);
};

//Map.cpp
#include "Map.h"
#include "Player.h"

void Map::bar(Player & p)
{
  p.foo(*this);
}

class Player;

class Map
{
};

Player.h:

class Map;

class Player
{
};

Was ist an meinem Beispiel nicht zu verstehen?

map- und playernumber sind arrays.

#ifndef MAP_H
#define MAP_H
#include <iostream>
#include "player.h"
using namespace std;

class Map
{
public  :
	Map();
    void createBlock(Map mapnum);
	void deleteBlock(Map mapnum, Player playernumber);
	void clearMap(Map mapnum,int mapwidth , int mapheight);

	int  MapWidth;
	int  MapHeight;

	struct S_Map
	{
		bool InUse;
		int  ID;
	};

	S_Map Map1[79][23];
};

#ifndef PLAYER_H
#define PLAYER_H
#include <iostream>
#include "map.h"
using namespace std;

class Player
{
public  :
	Player();
	void DevideBonus(Player playernumber);
	void NamePlayer(Player playernumber);
	void HealPlayer(Player playernumber);
	void KillPlayer(Player playernumber);
	void PlayerMove(Player playernumber, char direction[20], Map mapnum);
	void LevelUp(Player playernumber);
	void GiveXP(Player playernumber);
	int  DestPoints;
	int  X_player;
	int  Y_player;
private :
	int  LivePoints;
	int  XPPoints;
	int  BonusPlayer;
	int  Level;
	char PLayerName[20];
	bool GhostMode;
};

#endif;

1. Übergabe von Objekttypen sollte als "const Reference" geschenen
2. Wieso übergibst du Methoden der Klasse "Map" eine "Map"? (Analog "Player")
3. In deiner map.h fehlt das #endif
4. Wieso ist "PlayerName" kein std::string?
5. "char direction[20]" - wenn die Anzahl der möglichen Richtungen fest vorgegeben ist, sollte das besser ein enum sein
6. Warum übergibst du Map::clearMap die Breite und Höhe?

meine frage ist aber wie ich dass beides includieren kan nicht wass ich für fehler mache

das haben wir dir ja nun oft genug erklärt. Wenn du Parameterübergaben nicht als call-by-value machst, sondern als call-by-reference, benötigst du das include nicht, sondern kannst auf forward declarations zurückgreifen.

Das war jetzt meine letzte hilfreiche Antwort. Solange ich nicht das Gefühl habe, dass du auch nur ansatzweise versuchst, unsere Antworten nachzuvollziehen oder gar Eigeninitiative zu zeigen, werde ich hier nichts mehr schreiben.

Und ich hoffe, auch sonst keiner.

könntest du basierend auf der player.h und der map.h die bereits herausgegeben habe eine solche forward deklaration durchführen ?

das hat Skym0sh0 schon auf der ersten Seite getan.