Ich habe hier ein kleines Projektchen und auch ein kleines Problemchen
Ich habe verschiedene .cpp und .hpp Dateien und will nun von einer Funktion "Anfang" die Funktion "Weiter" aufrufen die in der selben Datei sind, aber von der Funktion "Weiter" geh ich dann nochweiter auf eine Funktion "Nochweiter" in einer anderen Datei.

Nun bräuchte ich aber einen Variableninhalt in "Nochweiter" die in "Anfang" verwendet wurde..

Ich hoffe ihr kommt draus wie ich das meine...

Danke für die Antworten!

void Anfang()
{
  int x = 5;
  Weiter(x);
}

void Weiter(int input)
{
  NochWeiter(input);
}

void NochWeiter(int xyz)
{
  cout << "Value: " << xyz << endl;
}

in deinem Beispiel will ich z.b. in der Funktion "Anfang" dann nach dem Aufruf von "Weiter" mit der Variable xyz weiter was anfangen...
aber er kennt sie dann da ja nicht..

du musst die funktionen einfach was zurückgeben lassen

Ansonsten geht auch sowas:

struct myStruct
{
  std::string stringVar;
  int intVar;
  int intVar2;
}

void MachWas(myStruct& ms)
{
  ms.stringVar = "changed";
}

Danke nochmals für die Antworten, aber was wenn ich mehrere Variablen habe?

Beispiel?

geht dasselbe auch mit einem Array? z.b. Array "NochvielWeiter[10][10]"?

dann einfach im code

int NochvielWeiter[10][10] = Weiter(vielWeiter[10][10])

?

Generell kommst du gerade irgendwie vom Hundersten ins Tausendste. Es gibt häufig mehrere Möglichkeiten der Modellierung. Je nach konkretem Problem sind einige besser, andere schlechter. Allgemein lässt sich sowas selten sagen.

nein, mit Arrays geht das so nicht. Es geht, aber anders. (Präventiv:) Du solltest statt Arrays sowieso lieber std::vector nehmen.

Generell kommst du gerade irgendwie vom Hundersten ins Tausendste. Es gibt häufig mehrere Möglichkeiten der Modellierung. Je nach konkretem Problem sind einige besser, andere schlechter. Allgemein lässt sich sowas selten sagen.

jo ich merke schon das ich grad bisschen überfordert werde mit dem Schritt, aber irgendwie will ich einfach eine schöne lösung für mein Problem finden aber find sie einfach nicht..

Globale Variablen will ich nicht..
Arrays hab ich keine Ahnung..

std::vector kannst du wie einen einfachen Datentyp als Parameter über- bzw. zurückgeben.

std::vector machWas(int x)
{
  std::vector myVector;
  myVector.push_back(x);

  MachNochMehr(myVector);

  return myVector;
}

void MachNochMehr(std::vector& vec)
{
  vec.push_back(5);
  vec.push_back(vec.size());
}

}

gruß
syntax

Vielen Dank, mit der return würde es so wie ich das Projekt habe funktionieren, aber ich denke das ich das eben immer weiter entwickle und dann plötzlich 2 Variablen habe, darum frage ich jetzt schon was währe wenn

In der Regel sind Werte, die aus der selben Funktion stammen, nicht unabhängig voneinander, sondern Teil der gleichen Abstraktion. Es ist also zu erwarten, dass sie von vornherein durch eine entsprechende Klasse oder ggf. einen Container abgebildet werden können. Aus vielen Werten wird dann automatisch wieder nur einer.
In den eher seltenen Fällen (primär bestimmte Arten von generischem Code), wo tatsächlich nur Mengen von Werten ohne inneren Zusammenhang entstehen, gibt es Möglichkeiten, diese temporär in Tupeln zusammenzufassen (std::tie).

Ich habe ein ganz einfaches Spielchen hier, wobei ich eine Map in einer Datei habe und diese aus 1en und 0en besteht, und ich diese Datei nun in die Variable dieMap[100][100] lade in der Funktion LoadMap. Nun brauch ich aber diese Variable auch wenn ich mit dem Spieler rumlaufe, da ich ja kollision abfragen muss, und darum muss ich von der Funktion MovePlayer, wo aber in der Datei Player.cpp ist, auf die Variable dieMap, die in Map.cpp drin ist, zugreifen können..

Klar könnte ich das jetzt mit return machen, aber ich denke das später nochmals eine funktion kommmt die dann diese Variable will und dann steh ich wieder vor demselben Problem...

ich möchte ungern dieMap global definieren, aber wie mache ich das gewisse Funktionen aus anderen Dateien zugriff auf diese erlangen ohne global?

könnte so aussehen:

// CMap.h
class CMap
{

private:

    CMap(); // Wichtig: Konstruktor ist private!

public:

    int arr[100][100]; // Die Map

    // Beispielfunktionen:
    void LoadMap(); // Laden einer Map

    static CMap& Instance()
    {
        static CMap m;
        return m;
    }

};
// Implementierung von LoadMap in CMap.cpp

// Zugriff dann so:

CMap::Instance().LoadMap();
CMap::Instance().arr[0][0] = 1;

// oder so:

CMap& myMap = CMap::Instance(); //Referenz!
myMap.LoadMap();
int i = myMap.arr[1][2];

So kannst du dann in allen Funktionen auf die gleiche Map zugreifen, die du einmal geladen hast, da es von der Klasse CMap nur eine Instanz gibt ,die die Klasse selber besitzt.

Also ich find das schön...

CMap(); // Wichtig: Konstruktor ist private!

Das sollte allerdings der Copy-ctor sein...

Jochen S. schrieb:

CMap(); // Wichtig: Konstruktor ist private!

Das sollte allerdings der Copy-ctor sein...

Jaja, hast ja recht. Den Zuweisungsoperator müsste man auch noch private machen, den Destruktor eigentlich auch

error LNK2001: Nicht aufgelöstes externes Symbol ""private: __thiscall SMap::SMap(void)" (??0SMap@@AAE@XZ)".

bei

SMap::Instance().LoadMap("map.txt");

Singleton.hpp

class SMap

{
private:
	SMap();

public:

	int mapFile[100][100];

	void LoadMap(const char *filename);

	static SMap &Instance()
	{
		static SMap m;
		return m;
	}

};

Singleton.cpp

#include "stdafx.h"
#include "SingletonMap.hpp"
#include <fstream>

void SMap::LoadMap(const char *filename)
{
	int mapSizeX, mapSizeY, loadX, loadY;
	std::ifstream openfile(filename);
	if(openfile.is_open())
	{
		openfile >> mapSizeX >> mapSizeY;
			while(!openfile.eof())
			{
				openfile >> mapFile[loadX][loadY];
				loadX++;
				if(loadX >= mapSizeX)
				{
					loadX = 0;
					loadY++;
				}
			}
	}	
}

int mapFile[100][100];

Map.cpp

void Map::DrawMap(sf::RenderWindow *mainWindow)

{

	SMap::Instance().LoadMap("map.txt"); //

}

Singleton.hpp

class SMap
{
private:
	SMap(); // hat keine Definition -> "unresolved external Symbol"

public:
	int mapFile[100][100]; // warum public?
/* ... */
};

Singleton.cpp

void SMap::LoadMap(const char *filename)
{
	int mapSizeX, mapSizeY, loadX, loadY; // loadX und loadY bleiben bis zur Verwendung uninitialisiert!?
/* ... */
}

int mapFile[100][100]; // <-- wofür?

Map.cpp

void Map::DrawMap(sf::RenderWindow *mainWindow) // <- Noch eine Map-Klasse (deren Deklaration du uns unterschlägst) !?
{
/* ... */
}

ich musste einfach n leeren Konstruktor machen ;p

int mapFile[100][100]; // <-- wofür?

Das frage ich mich auch schon länger, aber immer wenn ich irgendwas nicht aufgelöst hab und am schluss hinschreib klappt es.... warum, das weis ich leider noch nicht

greetz KN4CK3R