gegenseitiges includieren

WhileTrueDo

ich habe mir eine map.h und eine player.h erstelt, allerdings brauchen sie die funktionen und variablen der anderen. wie kann ich beide gegenseitig includieren ohne die beiden klassen in eine .h datei zu schreiben?

daddy_felix

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

WhileTrueDo

daddy_felix schrieb:

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

sind dass die einzigen möglichkeiten?

Fuchs aus dem Wald

Du baust sonst ein Kreis, überleg dir mal was du vorhast.

Skym0sh0

Inversion of Control gibts noch.

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.

WhileTrueDo

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

daddy_felix

"include" bedeutet "Textersetzung".

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...

WhileTrueDo

könntest du mir dannn bitte genau schreiben wie ich das machen soll also auch mit den namen meiner klassen und header?

Skym0sh0

// Player.h
#pragma once

class Map; // Forward Declaration

class Player
{
public:
  void foo(Map & m);
};

// 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);
}

daddy_felix

Map.h:

class Player;

class Map
{
};

Player.h:

class Map;

class Player
{
};

WhileTrueDo

ich schreibe meine funktionen ganz normal in die class und kann sie ganz normal definieren und nutzen oder?

Skym0sh0

Hä?
Ich versteh die Frage nicht. Es sei denn ich missverstehe das Offensichtliche.

Was ist an meinem Beispiel nicht zu verstehen?

WhileTrueDo

wo baue ich die funktion der player class "moveplayer(char Direction, Player playernumber, Map mapnumber)" und die der class Map ein?

map- und playernumber sind arrays.

Skym0sh0

Sorry, aber so ungenau wie du Fragen stellst und deinen Quellcode beschreibst, fällt mir grad nur das hier ein: Link

Du baust die Funktion nicht ein, sondern du übergibst eine Referenz dem Konstruktor. Dann kannst du die Funktionen in deiner Klasse aufrufen.

daddy_felix

Wieso brauchen Player und Map dieselbe Methode?

WhileTrueDo

nein nicht die selbe. dass sieht so aus :

#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;

daddy_felix

Lies bitte erstmal ein gutes Grundlagenbuch.

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?

Skym0sh0

7. Wieso ist Map1 in der Map-Klasse kein vector<vector<S_Map>>?
8. Wieso ist in der Map-Klasse nichts privat gekapselt?

WhileTrueDo

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