Der beste Weg zum Spieleprogrammieren

[cooky451]

Skotchy schrieb:

und (so denke ich) habe map verstanden (ich lasse mich auch gern eines besseren belehren).

Dann werde ich das mal machen.
Bedenke noch einmal:

map<string, string> m;
m[SCHLUESSEL] = WERT.

Wie sieht jetzt noch gleich die Datei aus?

Die Datei schrieb:

Schlüssel Wert
Schlüssel Wert
...

So wie du es jetzt machst, änderst du immer nur den Wert des Schlüssels "meintext".

Dann noch kleine Anmerkungen:
ifstream hat einen Konstruktor, da brauchst du dann kein open mehr:

ifstream datei("text.txt");

Das close am Ende kannst du hier auch sparen, das macht der Destruktor. (RAII ist schon was Tolles. :p)

Zudem sollte die Funktion (hätte ich vielleicht deutlicher machen sollen) nur auslesen, aber nichts ausgeben. Das soll dann wieder in der main() geschehen.

[Skotchy]

Und die nächste Version des Programms ist raus:

#include <iostream>
#include <map>
#include <limits>
#include <fstream>
#include <string>

void Auslesen()
{
    using namespace std;

	int i = 0;

    ifstream MeineDatei ("TestDokument.txt", ios::in);
    map <int, string> text;

	while(getline (MeineDatei, text[i]))
		i++;

	for (int j = 0; j != text.size() - 1; j++)
		cout << "Text " << j << " ist " << text[j] << endl;
}

int main()
{
    using namespace std;
    ifstream MeineDatei ("TestDokument.txt");
    if (MeineDatei.is_open())
	{
        Auslesen();

	}

    else
        cout << "Fehler beim Auslesen der Daten!" << endl
        << "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";

	cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
}

Allerdings habe ich immer noch ein Problem:
ich bekomme die maps nicht aus der Funktion und kann sie deswegen nich in der mein() Funktion ausgeben.
Allerdings habe ich map jetzt verstanden (oder?!).

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

Allerdings habe ich immer noch ein Problem:
ich bekomme die maps nicht aus der Funktion und kann sie deswegen nich in der mein() Funktion ausgeben.

Dann lies noch mal etwas über Rückgabewerte oder Referenzen oder Pointer. (Ein Pointer ist hier allerdings eher C-Stil und nicht zu bevorzugen, aber es funktioniert.)

Skotchy schrieb:

Allerdings habe ich map jetzt verstanden (oder?!).

Ich fürchte nicht. Um das noch mal klar zu machen, der Dateiaufbau:

Schlüssel Wert
Schlüssel Wert
..

Beides sind Strings, du brauchst also eine std::map<std::string, std::string>!

Und getline() ist hier, wie ich bereits erwähnt hatte, nicht gerade das Optimum. Denn getline() liest, wie der Name schon vermuten lässt, eine ganze Zeile auf einmal aus. Dann musst du allerdings noch den Schlüssel von dem Wert trennen, das ist unnötig kompliziert. Guck dir noch mal operator >> an.

[Skotchy]

So jetzt hab ich die map aus der Funktion rausbekommen, allerdings habe ich jetzt den ganzen Text in map bzw. String.
Und wie ich den Operator>> hier anwenden soll weiß ich leider auch nicht. Ich wüsste nur wie ich den Operator>> mit cin anwenden könnte.

Hier aber erstmal meine nächste Version des Programms:

#include <iostream>
#include <map>
#include <limits>
#include <fstream>
#include <string>
#include <Windows.h>

void Auslesen(std::string &t)
{
    using namespace std;
	ifstream MeineDatei ("TestDokument.txt");
	while (!MeineDatei.eof()){
		t += MeineDatei.get();
//		t >> MeineDatei.get();
	}
}

int main()
{
    using namespace std;
    ifstream MeineDatei ("TestDokument.txt");
    if (MeineDatei.is_open())
	{
		map <string, string> Text;
        Auslesen(Text["Text"]);

		cout << Text["Text"];
	}

    else
        cout << "Fehler beim Auslesen der Daten!" << endl
        << "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";

	cin.clear();
    cin.ignore();
}

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

So jetzt hab ich die map aus der Funktion rausbekommen,

Zumindest ist das mit der Referenz ein brauchbarer Ansatz. Jetzt überlege, wie du wirklich die std::map und nicht nur einen String nutzen kannst.

Skotchy schrieb:

Und wie ich den Operator>> hier anwenden soll weiß ich leider auch nicht. Ich wüsste nur wie ich den Operator>> mit cin anwenden könnte.

Hm.. wie wäre es denn, sich mal das Beispiel anzusehen was man auf meinem Link oben betrachten kann? Ein Tipp: Die Anwendung sieht genau so aus wie bei std::cin.

Aber die std::map hast du immer noch nicht verstanden. Du liest weiterhin alles in den Schlüssel "Text" ein.

[Skotchy]

cooky451 schrieb:

Jetzt überlege, wie du wirklich die std::map und nicht nur einen String nutzen kannst.

also muss ich:

void Auslesen (std::map<std::string, std::string> &text)

benutzen, oder liege ich da falsch?

cooky451 schrieb:

Ein Tipp: Die Anwendung sieht genau so aus wie bei std::cin.

Also:

ifstream& >> text["test"]

oder lige ich hier(wieder) falsch? Ich habe das schon ausprobiert, aber ich bekomme immer '>>' rot unterstrichen und 'Error: Es wurde ein Bezeichner erwartet.'
Auserdem wüsste ich nicht wie ich den String "test" ändern könnte damit ich beliebig viele Wörter aus dem Dokument Auslesen kann.
Oder (so wie ich map verstanden habe): weiß ich nicht wie ich den Schlüssel("test") ändern könnte um ihnen dann die Werte(Wörter/Zeilen) zuzuordnen, weil sie im string-format vorliegen( mit int könnte ich den Schlüssel in einer for-Schleife ändern).

Über weitere Tipps würde ich mich freuen und weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

also muss ich:

void Auslesen (std::map<std::string, std::string> &text)

benutzen, oder liege ich da falsch?

Das ist so korrekt, fehlt nur noch der Dateiname als zweiter Parameter. Du könntest die map zwar auch aus der Funktion zurückgeben (std::map<std::string, std::string> Auslesen(const char *dateiname)), aber das ist so absolut in Ordnung.

Skotchy schrieb:

Also:

ifstream& >> text["test"]

oder lige ich hier(wieder) falsch? Ich habe das schon ausprobiert, aber ich bekomme immer '>>' rot unterstrichen und 'Error: Es wurde ein Bezeichner erwartet.'

Aha, da liegt das Problem. std::cin ist eine Instanz von istream. Du schreibst ja auch nicht istream >> s. Ist der Groschen gefallen?

std::ifstream infile("test.txt");
std::string s;
infile >> s;

Skotchy schrieb:

Auserdem wüsste ich nicht wie ich den String "test" ändern könnte damit ich beliebig viele Wörter aus dem Dokument Auslesen kann.
Oder (so wie ich map verstanden habe): weiß ich nicht wie ich den Schlüssel("test") ändern könnte um ihnen dann die Werte(Wörter/Zeilen) zuzuordnen, weil sie im string-format vorliegen( mit int könnte ich den Schlüssel in einer for-Schleife ändern).

Wenn ich dir das jetzt einfach sage, habe ich die Aufgabe ja für dich gelöst. Aber ein Tipp: Du kannst auch eine Variable benutzen! Also Folgendes ist möglich:

std::map<std::string, std::string> m;
std::string s = "Hallo, ";
m[s] = "Welt!";

[Skotchy]

So habe ich das jetzt 'gelöst':

#include <iostream>
#include <map>
#include <limits>
#include <fstream>
#include <string>

void Auslesen(std::map<std::string, std::string> &text, std::string s)
{
    using namespace std;
	int i = 0;
	ifstream MeineDatei ("TestDokument.txt");

	while (!MeineDatei.eof()){
		s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i];
		MeineDatei.get();
		MeineDatei >> text[s];
		++i;
	}
}

int main()
{
    using namespace std;

	string schluessel;
	map <string, string> Text;
    ifstream MeineDatei ("TestDokument.txt");
    if (MeineDatei.is_open())
	{
        Auslesen(Text, schluessel);

		for(int i = 0; i != Text.size(); ++i)
		{
			schluessel = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i];
			cout << Text[schluessel];
		}
	}
	else
        cout << "Fehler beim Auslesen der Daten!" << endl
        << "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";

	cin.clear();
    cin.ignore();
}

Und irgendwo habe ich etwas vergessen oder übersehen oder sonst etwas, denn ich habe 2 Fehler, die hoffentlich meine letzten sind bzw. in diesem Programm sein werden.
Und zwar:
1. wird der erste Buchstabe nicht ausgegeben.
2. werden keine Leerzeichen und Absätze erkannt/benutzt.

Und noch eine Frage: ist die Lösung für den Schlüssel mit 'schluessel = "ABC..."[i];' eine gute bzw passend Lösung für die Namensgebung oder gibt es da bessere?

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

Und noch eine Frage: ist die Lösung für den Schlüssel mit 'schluessel = "ABC..."[i];' eine gute bzw passend Lösung für die Namensgebung oder gibt es da bessere?

Tja, du scheinst die map<> jetzt zwar irgendwie verstanden zu haben, aber scheinbar die Aufgabenstellung nicht. Du nutzt als Schlüssel wieder im Programm selbst vorgegebene Dinge. Bedenke den Aufbau der Datei!

Schlüssel Wert
Schlüssel Wert
...

Für die Ausgabe in der main()-Funktion solltest du dir Iteratoren ansehen.

(Falls du lieber erstmal eine "Musterlösung" sehen möchtest, weil du das Gefühl hast so nicht weiter zu kommen sag Bescheid.)

[Skotchy]

Jetzt habe ich ein Programm gebastelt, das irgendwo einen Fehler hat:

#include <iostream>
#include <map>
#include <fstream>
#include <string>

void Auslesen(std::map<std::string, std::string> &text, std::string &s)
{
    using namespace std;
	ifstream MeineDatei ("TestDokument.txt");
	int i = 0;

	while (!MeineDatei.eof())
	{
		MeineDatei.get();
		MeineDatei >> s[i];
		MeineDatei.get();
		MeineDatei >> text[s];
		i++;
	}
}

int main()
{
    using namespace std;

	map <string, string> Text;
    ifstream MeineDatei ("TestDokument.txt");
	string schluessel[5];
	int i = 0;

    if (MeineDatei.is_open())
	{
        Auslesen(Text, schluessel[0, 1, 2, 3, 4]);

		for(Text.begin(); Text.begin() != Text.end(); Text.begin()++, i++)
		{
			cout << Text[(string)schluessel[i]];
		}
	}
	else
        cout << "Fehler beim Auslesen der Daten!" << endl
        << "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";

	cin.clear();
    cin.ignore();
}

Ich vermute das sich der Fehler in der while-Schleife versteckt hat.

cooky451 schrieb:

(Falls du lieber erstmal eine "Musterlösung" sehen möchtest, weil du das Gefühl hast so nicht weiter zu kommen sag Bescheid.)

Wenn der Fehler in meinem Programm groß genug ist, würde ich mir gern die Musterlösung ansehen .

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

Wenn der Fehler in meinem Programm groß genug ist, würde ich mir gern die Musterlösung ansehen .

Nja, jetzt hast du es fast.

Skotchy schrieb:

#include <iostream>
#include <map>
#include <fstream>
#include <string>

void Auslesen(std::map<std::string, std::string> &text, std::string &s) // Wozu der std::string?
{
    using namespace std;
	ifstream MeineDatei ("TestDokument.txt"); // Das hier soll als Parameter übergeben werden. Entweder als "const char *", oder als "const std::string&")
	int i = 0; // Wozu das?

	while (!MeineDatei.eof()) // Tipp: http://www.cplusplus.com/reference/iostream/ios/operator_voidpt/
	{
		MeineDatei.get(); // Wozu?
		MeineDatei >> s[i]; // Warum s[i]?
		MeineDatei.get(); // Wozu?
		MeineDatei >> text[s]; // Hier bist du auf dem richtigen Weg.
		i++; // ..?
	}
}

int main()
{
    using namespace std;

	map <string, string> Text; // Korrekt
    ifstream MeineDatei ("TestDokument.txt"); // Hä? Du öffnest die Datei doch in der Funktion!
	string schluessel[5]; // Hä?
	int i = 0; // ??

    if (MeineDatei.is_open())
	{
        Auslesen(Text, schluessel[0, 1, 2, 3, 4]); // Was soll "schluessel"?

		for(Text.begin(); Text.begin() != Text.end(); Text.begin()++, i++) // Siehe Beispiel unten. :)
		{
			cout << Text[(string)schluessel[i]];
		}
	}
	else
        cout << "Fehler beim Auslesen der Daten!" << endl
        << "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";

	cin.clear();
    cin.ignore();
}

Über einen Vektor kannst du mit Iteratoren z.B. so iterieren:

std::vector<int> v;
v.push_back(5);
...
for (std::vector<int>::const_iterator i = v.begin(); // i zeigt auf das erste Element des Vektors
  i != v.end(); ++i) // v.end() zeigt genau ein Element hinter das Letzte
{
  std::cout << *i;
}

Letzter Versuch. Du solltest dir nur im Klaren darüber sein, wenn du Spiele programmieren möchtest, sollte man die Aufgabe in ~2-3 Minuten gut lösen können.

[Skotchy]

So, dann ist das hier also die letzte Version meines Programms, allerdings mit ein paar Unklarheiten

#include <iostream>
#include <map>
#include <fstream>
#include <string>
#include <vector>

void Auslesen(std::map<std::string, std::string> &text)
{
    using namespace std;
	ifstream MeineDatei ("TestDokument.txt");
	//const string &a = MeineDatei ("TestDokument.txt"); //Total falsch oder?!

	if ((void*)MeineDatei == 0){
		cerr << "Fehler beim Auslesen der Daten!" << endl
		<< "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";
		return;
	}

	while (MeineDatei.good())
	{
		MeineDatei >> text/*Hier müsste das erste Wort der Zeile aus der Datei als Schlüssel rein, oder?*/;
		//Hier müsste ich den vector v mit text[] füttern oder?
	}
}

int main()
{
    using namespace std;

	vector<int> v;
	v.push_back (5);
	map <string, string> Text;

    Auslesen(Text);

	for(vector<int>::const_iterator i = v.begin(); i != v.end(); ++i)
	{
		cout << *i;
	}

	cin.clear();
    cin.ignore();
}

Ich denke mal, dass alles was mir unklar ist im code als Kommentar steht. Bin jetzt eigendlich nur noch gespannt, ob diese oder die vorherige Version näher an der Lösung bzw. an der Musterlösung ist.

Edit: LoL warum wird der Code nicht als Code angezeigt ?!

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

#include <iostream>
#include <map>
#include <fstream>
#include <string>
#include <vector>

void Auslesen(std::map<std::string, std::string> &text)
{
    using namespace std;
	ifstream MeineDatei ("TestDokument.txt");
	//const string &a = MeineDatei ("TestDokument.txt"); //Total falsch oder?!

	if ((void*)MeineDatei == 0){
		cerr << "Fehler beim Auslesen der Daten!" << endl
		<< "Bitte pruefen sie ob \"TestDokument.txt\" existiert und im richtigen Ordner ist!";
		return;
	}

	while (MeineDatei.good())
	{
		MeineDatei >> text/*Hier müsste das erste Wort der Zeile aus der Datei als Schlüssel rein, oder?*/;
		//Hier müsste ich den vector v mit text füttern oder?
	}
}

int main()
{
    using namespace std;

	vector<int> v;
	v.push_back (5);
	map <string, string> Text;

    Auslesen(Text);

	for(vector<int>::const_iterator i = v.begin(); i != v.end(); ++i)
	{
		cout << *i;
	}

	cin.clear();
    cin.ignore();
}

Der Syntaxhighlighter verträgt sich wohl nicht mit [].
Joa, schon besser.

Blubb:

void readFile(std::map<std::string, std::string>& keys, const char *filename)
{
  std::ifstream in(filename);
  if (in.good())
  {
    std::string s;
    while (in >> s && in >> keys[s])
      ;
  }
  else
  {
    std::cerr << "Could not open file: " << filename << "\n";
  }
}

int main()
{
  std::map<std::string, std::string> keys;
  readFile(keys, "keys.txt");
  // auto ist hier gleichbedeutend mit: std::map<std::string, std::string>::const_iterator
  for (auto i = keys.begin(); i != keys.end(); ++i)
    std::cout << i->first << ": " << i->second << "\n";
  getchar(); // Ganz böse!
}

Frag, falls du irgendetwas nicht verstehst, oder wenn du noch eine Aufgabe willst.

[Skotchy]

Eine paar Fragen hab ich da schon zu dem Code:
1. Hätte ich gerne die while-Schleife erläutert bekommen.
2. Was ist der Unterschied zwischen 'endl' und '"\n"' ? Beide sorgen dafür das der folgende Text in der nächsten Zeile ausgegeben, richtig? Aber wo liegt der unterschied?(oder gibt es da keinen?)
3. Eine Verständnisfrage: 'i->first' Zeigt auf das erste Element aus 'i' und 'i->second' auf das zweite bzw. indem Fall auf die folgenden Elemente, richtig?
4. Warum ist 'getchar()' so böse?

So, dass waren dann meine Fragen und über noch eine Aufgabe würde ich mich auch freuen .

Weiterhin danke für eure Hilfe.

-Skotchy

[cooky451]

Skotchy schrieb:

1. Hätte ich gerne die while-Schleife erläutert bekommen.

Das war der Tipp mir operator void*. operator >> gibt selbst eine Referenz auf das Objekt zurück.
(z.B: istream& operator>> (float& val ); )
Und bei dem Objekt selbst ist wieder operator void* überladen:

Return Value
null pointer if either failbit or badbit is set.
A non-null pointer otherwise.

Das wird da ausgenutzt. Letztendlich besteht die Schleife also nur aus "lies bis zum Ende."

Dazu wird im linken Teil der Schlüssel ausgelesen und im rechten Teil wird dann der Wert des Schlüssels in der std::map gesetzt.

Skotchy schrieb:

2. Was ist der Unterschied zwischen 'endl' und '"\n"' ? Beide sorgen dafür das der folgende Text in der nächsten Zeile ausgegeben, richtig? Aber wo liegt der unterschied?(oder gibt es da keinen?)

std::endl ist ein "\n" + std::flush. Wenn du das flush nicht brauchst, nutze "\n", da das logischerweise performanter ist.

Skotchy schrieb:

3. Eine Verständnisfrage: 'i->first' Zeigt auf das erste Element aus 'i' und 'i->second' auf das zweite bzw. indem Fall auf die folgenden Elemente, richtig?

Nein. Der Iterator über eine std::map zeigt auf ein std::pair. first/second sind member von std::pair, bei einer std::map sind sie gleichbedeutend mit "Schlüssel" und "Wert".

Skotchy schrieb:

4. Warum ist 'getchar()' so böse?

1. Weil es C ist und man C und C++ nicht unbedingt mischen sollte und 2. weil man Konsolen-Programme normalerweise einfach zu Ende laufen lässt. (Nur ist das unter Windows zum testen halt nervig.)

[Skotchy]

Vor der nächsten Aufgabe hätte ich da nochmal eine Frage.
Dieses Auslesen einer Datei kann man doch (auch) dazu benutzen um Spielstände zu laden, richtig? Dann müsste man für das Speicher die Datei einfach ändern bzw. neu beschreiben, oder?

Weiterhin danke für eure Hilfe.

-Skotchy

[Fake oder Echt]

Will mich nicht großartig einmischen, finde gut, dass du ihm hilfst, habe nur mal an dich (cooky451) ne Frage ..

cooky451 schrieb:

ifstream hat einen Konstruktor, da brauchst du dann kein open mehr:

ifstream datei("text.txt");

Das close am Ende kannst du hier auch sparen, das macht der Destruktor. (RAII ist schon was Tolles. :p)

Gehen wir davon aus wir haben einen Gültigkeitsbereich, in dem ein Stream geöffnet wird. Irgendwo zwischendrin schmiert das Programm ab, ohne eine Exception zu werfen. Die Dateioperationen sind längst abgeschloßen. Was ist die Folge: Destruktor wird nicht aufgerufen, Datei wird nicht geschloßen, lässt sich vom User nicht mehr bearbeiten/verschieben/löschen weil Windoof sagt "Datei in Verwendung". Warum dann kein close () verwenden um sowas zu vermeiden? Oder sehe ich da was Falsch?

Also z.B.

{ // Gültigkeitsbereich
    ifstream bla ("datei.txt");

    /* Mache hier alle gewünschten Operationen mit der Datei */

    /* Hier könnte jetzt ein bla.close () rein, weil alle Dateioperationen erledigt wurden */

    /* Hier schmiert das Programm ab, ohne Exception, d.h. Destruktor für bla wird nicht mehr aufgerufen */
}

[otze]

Fake oder Echt schrieb:

Gehen wir davon aus wir haben einen Gültigkeitsbereich, in dem ein Stream geöffnet wird. Irgendwo zwischendrin schmiert das Programm ab, ohne eine Exception zu werfen. Die Dateioperationen sind längst abgeschloßen. Was ist die Folge: Destruktor wird nicht aufgerufen, Datei wird nicht geschloßen, lässt sich vom User nicht mehr bearbeiten/verschieben/löschen weil Windoof sagt "Datei in Verwendung". Warum dann kein close () verwenden um sowas zu vermeiden? Oder sehe ich da was Falsch?

Wenn das Programm abstürzt (!= es wird eine Exception geworfen), dann liegt es im Tätigkeitsbereich des Betriebssystems alle Resourcen freizugeben. Du kannst an der Stelle nichts mehr machen. Im Grunde verlagerst du das Problem nur an einen anderen Ort. Der Code der vorher durch ctor/dtor eingerahmt wurde wird jetzt durch ctor/close() oder open()/close() eingerahmt. Macht keinen Unterschied. Natürlich solltest du trotzdem darauf achten, dass du Resourcen nicht zu lange verwendest. Aber das erreichst du durch modularisierung einfacher, als durch das willkürliche Einstreuen von close().

Mal dein Beispiel weiter kommentiert:

{ // Gültigkeitsbereich
    ifstream bla ("datei.txt");

    /* Mache hier alle gewünschten Operationen mit der Datei */

    /* Hier könnte jetzt ein bla.close () rein, weil alle Dateioperationen erledigt wurden */
    //das war ein deutlicher Gedanke, dass hier eine Bedeutungseinheit zuende ist, also ist alles was drüber kommt, eine Funktion

    /* Hier schmiert das Programm ab, ohne Exception, d.h. Destruktor für bla wird nicht mehr aufgerufen */
}

=>

SomeType readFile(){
    ifstream bla ("datei.txt");
    /* Mache hier alle gewünschten Operationen mit der Datei */

    /* lass den Destruktor aufräumen*/
}

{ // Gültigkeitsbereich
    SomeType type = readFile();

    /* Hier schmiert das Programm ab, ohne Exception, aber bla ist bereits kaputt, awesome!*/
}

[cooky451]

Skotchy schrieb:

Vor der nächsten Aufgabe hätte ich da nochmal eine Frage.
Dieses Auslesen einer Datei kann man doch (auch) dazu benutzen um Spielstände zu laden, richtig? Dann müsste man für das Speicher die Datei einfach ändern bzw. neu beschreiben, oder?

Ja, natürlich geht das. Du musst dir halt ein Format für die Spielstände überlegen in dem alle wichtigen Informationen abgespeichert werden (Punkte, Fortschritt, ...) und die schreibst du dann in eine Datei und kannst sie später wieder auslesen.

Das spezielle Beispiel mit der std::map hier könnte man für Werte und ähnliches sogar direkt benutzen, auch wenn der Zusammenhang eigentlich gar nicht geplant war.

[Skotchy]

cooky451 schrieb:

auch wenn der Zusammenhang eigentlich gar nicht geplant war.

ist doch supper, dann hab ich also indirekt mehr gelernt als vorgesehen war.

cooky451 schrieb:

Du musst dir halt ein Format für die Spielstände überlegen in dem alle wichtigen Informationen abgespeichert werden (Punkte, Fortschritt, ...) und die schreibst du dann in eine Datei und kannst sie später wieder auslesen.

wird zwar noch ein bisschen früh sein aber welche Formate empfehlen sich da besonders gut, oder gibt es da je nach Spiel andere die sich besser eignen?

Jetzt freue ich mich aber auf die nächste Aufgabe(und natürlich wieder, falls vorhanden, auf den 'versteckten' unbeabsichtigten Inhalt ).

Weiterhin danke für eure Hilfe.

-Skotchy