Gernerieren und speichern von Highscoreliste

[manuelmassari]

Hallo Leute,

ich bin C++-Neuling und habe vor Kurzem ein kleines Spiel entwickelt..bei dem Spiel ist es möglich Punkte zu sammeln und diese anschließend auslesen zu können..
ich wollte mir dazu eine kleine Highscoreliste schreiben, bei der bereits ein Startwert als Highscore vordefiniert ist. Die Liste soll anfangs leer sein und aus max. 10 Einträgen bestehen.
Immer, wenn der Spieler einen neuen Highscore erspielt hat, soll dieser in die Highscoreliste eingetragen werden, wenn der Wert darunter liegt, soll er entsprechend ignoriert werden.
Die Einträge in der Liste sollen ebenfalls "gespeichert" werden, sodass sie bei einem Neustart des Programms stets verfügbar sind..
Ich habe versucht diese Liste mit "verketteten Listen" zu generieren, was wunderbar geklappt hat, nur leider lassen sich diese nicht mit der Klasse fstream speichern.
Ich habe ebenfalls versucht die Einträge mittels normale Variablen in die Klasse "fstream" zu speichern, nur hier habe ich immer das Problem,dass immer nur ein Eintrag,bzw. der letzte gespeichert wird und ich somit keine
funktionelle "Liste" zusammen bringen kann..

ich habe nun wirklich alles versucht das Problem zu lösen, bin aber mittlerweile mit meinem Latein am Ende und ersuche euch dringend um Hilfe..

Vielen Dank schon einmal im Voraus..

im Anhang ein kleiner Ausschnitt meines (leider gescheiterten) Lösungsvorschlages:

ofstream Output ("Highscoreliste", ios:: binary | ios:: app);
Output.write ((char*) &Highscore, sizeof (Highscore));

ifstream Input ("Highscoreliste", ios:: binary);
Input.read ((char*) &Highscore, sizeof (Highscore));

[joggel]

Also, ich kann mir gut vorstellen, das der folgende Code nicht 100% korrekt ist.
Aber das ist dass, was ich so zusammen bekomme:

Code: Alles auswählen

// irgendwo in einem Header oder an einer globalen Stelle
const std::string zeilenUmbruchZeichen('\n');
const std::string separator(';');

// <HighscoreItem> 
struct HighscoreItem
{
 std::string mName;
 unsigned int mScore;
 HighscoreItem::HighscoreItem(const std::string& name, const unsigned int& score)
 : mName(name), mScore(score)
}

 std::vector<HighscoreItem> mHighscoreListe;
...

Da xtr3m kool code to write in a file

Code: Alles auswählen

// schreibe Funktion
void schreibe()
{
	ofstream outFile;
	outFile.open(fileName, ios_base::out);
	if( !outFile )
	{
		cout << "Fehler beim Erstellen der Datei!\n";
		return;
	}
	
	for(int i(0); i<mHighscoreListe().size(); ++i)
	{
		outFile.write( mHighscoreList.getFromIndex(i).mName.c_str(),mHighscoreList.getFromIndex(i).mName.size()+1 );
		outFile.write( separator.c_str(), 2 );
		outFile.write( reinterpret_cast<char*>(mHighscoreList.getFromIndex(i).mScores, 4 );	// 4 => unsigned int
		outFile.write( zeilenUmbruchZeichen.c_str(), 2 );
	}
	
	outFile.close();	
}

Da xtr3m kool code to read da data

Code: Alles auswählen

void lese()
{
	ifstream inFile;
	inFile.open(fileName, ios_base::in);
	if( !inFile )
	{
		cout << "Fehler beim Öffnen der Datei!\n";
		return;
	}
	
	mHighscoreList.clear();
	char lineBuffer[512] = '0';	// 512 Zeichen für das Lesen einer Zeile sollte doch ausreichen
	while( !inFile.eof() )
	{
		inFile.getline( lineBuffer, sizeof(lineBuffer) );
		std::string aChar;
		std::string name;
		int indexLineBuffer(0);
		while(separator != aChar)
		{
			aChar = std::string(lineBuffer[indexLineBuffer]);
			name += aChar
			++indexLineBuffer;
		}
		

		aChar = std::string(); // geht das? will <aChar> reseten.
		unsigned int score(0);
		std::string scoreString;
		while(aChar != zeilenUmbruchZeichen )
		{
			aChar = std::string(lineBuffer[indexLineBuffer]);
			scoreString += aChar;
			++indexLineBuffer;
		}
		
		// convert from std::string to int
		// <score> hat einen Wert
		mHighscoreList.push_back( HighscoreItem(name,score) );
	}	
}

Das sollte vom Prinzip her funktionieren (sollte!).
Wer Fehler entdeckt, kann die ja berichtigen.

Gruß

[manuelmassari]

Danke schon mal für Deinen Codeausschnitt, sollte sehr hilfreich gerade für mein Problem sein..da ich jedoch noch Neuling auf diesem Gebiet bin, gestaltet sich mein Verständnis für die Zusammenhänge dieser Codezeilen noch sehr schwierig..
was ich z.b. nicht ganz verstehe ist folgender Codeausschnitt:

while( !inFile.eof() )
{
inFile.getline( lineBuffer, sizeof(lineBuffer) );
std::string aChar;
std::string name;
int indexLineBuffer(0);
while(separator != aChar)
{
aChar = std::string(lineBuffer[indexLineBuffer]);
name += aChar
++indexLineBuffer;
}


aChar = std::string(); // geht das? will <aChar> reseten.
unsigned int score(0);

was bewirkt dieser genau? Das Schreiben in eine Datei ist mir relativ klar, das heißt Du generierst die Liste mit Hilfe von Vecotren und speicherst diese anschließend in der Klasse fstream..jedoch ist mir das Auslesen der Daten nicht ganz klar, welche Zeile bewirkt nun das "direkte" Auslesen der Daten (also der Kern der Funktion), bzw. welche Zeilen könnte man unter Umständen weglassen?

[joggel]

...was ich z.b. nicht ganz verstehe ist folgender Codeausschnitt:

while( !inFile.eof() )
{
inFile.getline( lineBuffer, sizeof(lineBuffer) );

es werden Zeichen aus der Datei gelesen. Und zwar Zeilenweise. Also bist ein '\n' auftaucht, oder die Anzahl der gelesen Zeichen dem des 2ten Paremeter entspricht. Dieser gibt an, wie viele Zeichen maximal gelesen werden dürfen.
Und das ganze geschieht in einer Schleife, die solange läuft bis das Ende der datei erreicht ist.
Also, was da pro Zeile passiert ist dann das:

Code: Alles auswählen

/*
 In jeder Zeile wird über jedes Zeichen in der Zeile gelesen und in die <mHighscoreList> kopiert wird.
 In jeder Zeile brauchen wir eine Variable für das einlesen des aktuellen Zeichens <aChar>.
 Eine Variable die den Namen des EIntrages trägt. Also, Spielername? Wenn erwünscht...
 Dann einen Zähler der die Position in dem Array <lineBuffer> zählt.
*/
                std::string aChar;
                std::string name;
                int indexLineBuffer(0);
/*
 Diese While-Schleife läuft solange bis das eingelesene (nächste) Zeichen der Eintrags-Trennungs-Zeichen ist. Hier habe ich sie (<separator >) einfach mit ';' initialisiert. Da es vlt. so gespeichert ist:
     Hans       5000
     Mr. X      1250
 wird in der Datei so gespeichert sein:
 Hans;5000
 Mr.X;1250
 Es muss also erkannt werden, bis wohin ein Eintrag geht.

 Die erste While-Schleife liest den Namen ein.
*/
                while(separator != aChar)     
                {
                        /* Ein Zeichen wird aus dem Buffer gelesen und gleich in ein std::string konvertiert. */
                        aChar = std::string(lineBuffer[indexLineBuffer]);
                        /* Das gelesene Zeichen wird an <name> gehangen. Es wird Buchstabe für Buchstabe der Name aus der Datei gelesen.*/
                        name += aChar
                        /* Der Buffer-Index-Zähler wird um inkrementiert.*/
                        ++indexLineBuffer;
                }

Jetzt haben wir den Namen gelesen.

Das ähnliche auch bei den Punkten.

Code: Alles auswählen

		// hier wollte ich eigentlich nur den string <aChar> leeren.
		// hab mich dazu dem default-Konstruktor bedient. 
		// Dieser erstellt mir einen Neuen string, der ja leer ist.
		aChar = std::string(); 
		unsigned int score(0);
		// in diese Variable, werden die einzelnen Werte, 
		// die die Punkt-Anzahl beschreiben solls, gespeichert.
		std::string scoreString;
		// die while-schleife geht so lange bist dieses Zeichen kommt: '\n' (Zeilenumbruch)
		while(aChar != zeilenUmbruchZeichen )
		{
				//ein einzelnses Zeichen gelesen
				aChar = std::string(lineBuffer[indexLineBuffer]);
				// Dies Zeichen wird dann in <scoreString> kopiert/angehangen.
				scoreString += aChar;
				// Position, in der wir uns im Array <lineBuffer> befinden.
				++indexLineBuffer;
		}
	   
		// convert from std::string to int
		// and copy to <score>
		hier kommt eine Umwandlung von std::string zu integer.
		Musst mal googeln.
		
		// Jetzt hat die Variable <score> einen Wert, sowie <name>
		// Diese werden jetzt noch in die <mHighscoreList> aufgenommen.
		mHighscoreList.push_back( HighscoreItem(name,score) );

Das geschieht jede Zeile, bis das Ende der Datei erreicht ist.
Ich hoffe ich hab mich verständlich ausgedrückt...

und außerdem hab ich lange weile ^^

[manuelmassari]

Alles klar, jetzt ist mir vielel leichter verständlicher..ich versuche das mal umzusetzten..Danke schon mal, ich melde mich, wenn ich zu einem Abschluss kome :D

[manuelmassari]

Hallo, ich bins wieder =),

ich habe mal versucht Deinen Vorschlag umzusetzen und zu kompilieren..ich habe am Beispiel nur geringfügige Änderungen vorgenommen, damit die meisten "Compilierfehler" verschwinden, einer bleibt jedoch nach wie vor:

"Unerwartetes Dateiende gefunden"..kannst Du dir daraus einen Reim machen? Im Anhang habe ich mal das Beispiel herauskopiert, das ich kompilieren möchte..

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

const char zeilenUmbruchZeichen('\n');
const char separator(';');
void schreibe ();
void lese ();

struct HighscoreItem
{
string mName;
unsigned int mScore;
HighscoreItem::HighscoreItem(const string& name, const unsigned int& score)
: mName(name), mScore(score)
}

int main ()
{
vector<HighscoreItem> mHighscoreListe;

schreibe ();
lese ();

return 0;
}

void schreibe()
{
ofstream outFile;
outFile.open(fileName, ios_base::out);
if( !outFile )
{
cout << "Fehler beim Erstellen der Datei!\n";
return 0;
}

for(int i=0; i<mHighscoreListe().size(); ++i)
{
outFile.write( mHighscoreList.getFromIndex(i).mName.c_str(),mHighscoreList.getFromIndex(i).mName.size()+1 );
outFile.write( separator.c_str(), 2 );
outFile.write( reinterpret_cast<char*> mHighscoreList.getFromIndex(i).mScores, 4 );
outFile.write( zeilenUmbruchZeichen.c_str(), 2 );
}

outFile.close();
}

void lese()
{
ifstream inFile;
inFile.open(fileName, ios_base::in);
if( !inFile )
{
cout << "Fehler beim Öffnen der Datei!\n";
return 0;
}

mHighscoreList.clear();
char lineBuffer[512] = '0';
while( !inFile.eof() )
{
inFile.getline( lineBuffer, sizeof(lineBuffer) );
string aChar;
string name;
int indexLineBuffer(0);
while(separator != aChar)
{
aChar = string(lineBuffer[indexLineBuffer]);
name += aChar
++indexLineBuffer;
}


aChar = string();
unsigned int score(0);
string scoreString;
while(aChar != zeilenUmbruchZeichen )
{
aChar = string(lineBuffer[indexLineBuffer]);
scoreString += aChar;
++indexLineBuffer;
}

mHighscoreList.push_back( HighscoreItem(name,score) );
}
}

[Schrompf]

Benutze bitte "[co.de=cpp]" ohne Punkt, um Quelltext zu posten.

Das "Unerwartete Dateiende" kann mehrere Ursachen haben, die im zweiten Teil der Fehlermeldung beschrieben werden, die Du leider nicht mit zitiert hast. Entweder ist der Compiler auf der Suche nach einer schließenden Klammer ans Dateiende gestoßen - dann hast Du irgendwo eine schließende Klammer vergessen. Oder er ist bei der Suche nach dem vorkompilierten Header. In diesem Fall sind Precompiled Header (PCH) in den Projekteinstellungen aktiviert, aber Du benutzt anscheinend keine Precompiled Header. Geh in die Projekteigenschaften des Projekts, Abteilung C++, Registerkarte Precompiled Header, und drehe dort die Einstellung auf "Nicht verwenden".

[joggel]

Hallo manuelmassari,

entschuldige vielmals.
Ich habe da etwas unüberlegt geschrieben.

Vlt. findet jemand anderes hier einen besseren Weg.
Ich habe jetzt einen Compiler zu Hand, und kann nun etwas besser testen.
Der neue Code ist nun folgender:

Code: Alles auswählen

#include "stdafx.h"
#include <vector>
#include <string>
#include <fstream>
#include <iostream>

using namespace std;

// irgendwo in einem Header oder an einer globalen Stelle
const string zeilenUmbruchZeichen("\n");
const string separator(";");

// <HighscoreItem>
struct HighscoreItem
{
 string mName;
 unsigned int mScore;
 HighscoreItem::HighscoreItem(const string& name, const unsigned int& score)
 : mName(name), mScore(score)
 {}
};

std::vector<HighscoreItem> mHighscoreListe;


// schreibe Funktion
void schreibe( const string& fileName )
{
    ofstream outFile;
	outFile.open(fileName.c_str(), ios_base::out);
    if( !outFile )
    {
            cout << "Fehler beim Erstellen der Datei!\n";
            return;
    }
   
    for(int i(0); i<mHighscoreListe.size(); ++i)
    {
		outFile.write( mHighscoreListe.at(i).mName.c_str(),mHighscoreListe.at(i).mName.size());
        outFile.write( separator.c_str(), 1 );
		outFile.write( reinterpret_cast<char*>(&mHighscoreListe.at(i).mScore), 4 );     // 4 => unsigned int
        outFile.write( zeilenUmbruchZeichen.c_str(), 1 );
    }
   
    outFile.close();       
}

void lese(const string& fileName)
{
    ifstream inFile;
	inFile.open(fileName.c_str(), ios_base::in);
    if( !inFile )
    {
            cout << "Fehler beim Öffnen der Datei!\n";
            return;
    }
   
    mHighscoreListe.clear();
    char lineBuffer[512] = "0";     // 512 Zeichen für das Lesen einer Zeile sollte doch ausreichen
    while( !inFile.eof() )
    {
        inFile.getline( lineBuffer, sizeof(lineBuffer) );
        std::string aChar;
        std::string name;
        int indexLineBuffer(0);
        while(separator != aChar)
        {
            aChar = std::string(1,lineBuffer[indexLineBuffer]);
            name += aChar;
            ++indexLineBuffer;
        }
       

        aChar = std::string(); // geht das? will <aChar> reseten.
        unsigned int score(0);
        std::string scoreString;
		unsigned int numberOfCharsForScore(0);
        while( numberOfCharsForScore!=4 )
        {
            aChar = std::string(1,lineBuffer[indexLineBuffer]);
            scoreString += aChar;
            ++indexLineBuffer;
			numberOfCharsForScore++;
		}
       
        // convert from std::string to int
		// Achtung!!!
		// Hier muss eine Konvertierung erfolgen, die auf aus einer Folge von Bits ein unsigned int
		// macht. Wie das jetzt funktioniert, kann ich leider im Moment nicht sagen.


        mHighscoreListe.push_back( HighscoreItem(name,score) );
    }      
}

int main(int argc, _TCHAR* argv[])
{
	mHighscoreListe.push_back( HighscoreItem("Hans",1000) );
	mHighscoreListe.push_back( HighscoreItem("Jochen",400) );
	mHighscoreListe.push_back( HighscoreItem("Werner",1300) );
	mHighscoreListe.push_back( HighscoreItem("Blub",2000) );

	schreibe("D:\\Highscores.txt");

	mHighscoreListe.clear();

	lese("D:\\Highscores.txt");

	return 0;
}

Wie gesagt: Bitte entschuldige.
Ich hatte, als ich den ersten Vorschlag geschrieben hatte, keine Entwicklungsumgebung zur Hand.
Auch dieses Schreiben der Punkte (score) bzw. einlesen dieser ist nicht gerade optimal! Zu mal ich jetzt auf die Schnelle keine Alternative weiß. Vlt. hat jemand hier einen anderen Vorschlag.
Und noch viel schlimmer: Ich weiß gerade auch keinen Weg für das konvertieren der Zeichenkette zu einem Zahlenwert :?
[/b]

[RazorX]

Warum denn nicht aus dem std::string HighscoreItem.mName einen z.B. char mName[64] machen und die Items sequentiell binär speichern? Ist wesentlich schneller und unkomplizierter als da die Zeilen zu parsen.

Edit: Quasi so (habs jetzt nicht getestet, vom Prinzip her halt)

Code: Alles auswählen

struct HighscoreItem {
    char mName[64];
    unsigned mPoints;
    // ...
};

void save(const std::vector<HighscoreItem>& items) {
     std::ofstream file("highscore.bin", std::ofstream::out | std::ofstream::binary);
     if(!file.good()) {
           // ...
     }

     unsigned size = items.size();
     file.write(reinterpret_cast<const char*>(&size), sizeof(unsigned));
     for(int i = 0; i < size; ++i) {
          file.write(reinterpret_cast<const char*>(&items[i]), sizeof(HighscoreItem));
     }

     file.close();
}

void load(std::vector<HighscoreItem>& items) {
     std::ifstream file("highscore.bin", std::ifstream::in | std::ifstream::binary);
     if(!file.good()) { ... }

     unsigned size = 0;
     file.read(reinterpret_cast<char*>(&size), sizeof(unsigned));
     for(int i = 0; i < size; ++i) {
          HighscoreItem item;
          file.read(reinterpret_cast<char*>(&item), sizeof(HighscoreItem));
          items.push_back(item);
     }

     file.close();
}

[manuelmassari]

Hallo alle zusammen,

bzgl. meinem Quellcode vorhin, habe ich jetzt die gesamte Fehlermeldung herauskopiert (wenn sich jemand einen Reim draus machen kann, warum das hier nicht geklappt haben könnte):

1>------ Erstellen gestartet: Projekt: Generieren von Highscoreliste, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>Generieren von Highscoreliste.cpp
1>c:\users\admin\documents\visual studio 2008\projects\generieren von highscoreliste\generieren von highscoreliste.cpp(90) : fatal error C1004: Unerwartetes Dateiende gefunden.
1>Das Buildprotokoll wurde unter "file://c:\Users\admin\Documents\Visual Studio 2008\Projects\Generieren von Highscoreliste\Debug\BuildLog.htm" gespeichert.
1>Generieren von Highscoreliste - 1 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========


ich danke Euch schon mal für Eure Anregungen, ich werde die Vorschläge gleich versuchen in meinem Beispiel einzubinden, bzw. erst mal den Quellcode Stück für Stück zu verstehen und zu kompilieren..ich sage Euch Bescheid, wie das kleine Experiment ausgegangen ist..

P.S. An "Joggl": Danke trotzdem für deine Hilfe, wie gesat, bin noch blutiger Anfänger und um jeden Tipp, bzw. Rat dankbar..

[RazorX]

Die MSDN ist bei Fehlermeldungen immer die erste Anlaufstelle.

http://msdn.microsoft.com/en-us/library ... s.71).aspx

deutsche Lokalisierung hab ich nicht genommen, da ich bei der Übersetzung mal wieder zu viel bekommen habe.

[EyDu]

Boost hat doch schon Serialisierung eingebaut, warum also das Rad noch einmal neu erfinden?

[RazorX]

Boost hat doch schon Serialisierung eingebaut, warum also das Rad noch einmal neu erfinden?

Weil als C++-Neuling man vielleicht von der Komplexität von Boost erschlagen wird und es aus Sicht des Lernens nicht verkehrt wäre diverse Techniken sich anzueignen.

[EyDu]

Irgendwann muss man ja mal mit Boost anfangen und da ist Serialisierung nun nicht unbedingt das schwerste Thema. Den Lerneffekt einer eigenen Serialisierung von Highscorelisten kann ich ehrlich gesagt nicht erkennen. Da gibt es viel interessantere Themen, für die man seine Zeit sinnvoll einsetzen kann.

[joggel]

So,

nun hatte ich mal Zeit das mal etwas genauer zu testen.
Ich bin zu folgendem Code gekommen:

struct "HighscoreItem"

Code: Alles auswählen

struct HighscoreItem
{
 string mName;
 unsigned int mScore;
 HighscoreItem::HighscoreItem(const string& name, const unsigned int& score)
 : mName(name), mScore(score)
 {}
};

schreibe-Funktion

Code: Alles auswählen

void write( const vector<HighscoreItem>& highscoreList, const string& outFileName )
{
	fstream file;
	file.open(outFileName.c_str(), ios::out);
	if( file.good()==false )
	{
		cout << "Fehler bei erstellen der Datei" << endl;
	}
	else
	{
		for(unsigned int index(0); index<highscoreList.size(); ++index)
		{
			file << highscoreList.at(index).mName << ";" << highscoreList.at(index).mScore << endl;
		}

	    file.close();
	}
}

einlesen-Funktion

Code: Alles auswählen

vector<HighscoreItem> read( const string& inFileName )
{
	std::vector<HighscoreItem> tempHighscoreListe;

	fstream file;
	file.open(inFileName.c_str(), ios::in);
	if( file.good()==false )
	{
		cout << "Fehler bei oeffnen der Datei" << endl;
	}
	else
	{
		string line;
		while (!file.eof())
		{
			getline(file,line, '\n');

			string name;
			unsigned int indexLine(0);
			for(indexLine=0; line.size()>0 && line.at(indexLine)!=char(';') ; ++indexLine)
			{
				name += line.at(indexLine);
			}

			string scoreStr;
			int score(0);
			indexLine++;
			for(indexLine; indexLine<line.size(); ++indexLine)
			{
				scoreStr += line.at(indexLine);
			}

			score = atoi(scoreStr.c_str());

			tempHighscoreListe.push_back(  HighscoreItem(name,score) );
		}
	}

	return tempHighscoreListe;
}

Verwendung

Code: Alles auswählen

#include "stdafx.h"
#include <vector>
#include <string>
#include <fstream>
#include <iostream>
...
// Funktionen-Deklaration:
void write( const vector<HighscoreItem>& highscoreList, const string& outFileName );
vector<HighscoreItem> read( const string& inFileName );
// **************************
...

int _tmain(int argc, _TCHAR* argv[])
{

	std::vector<HighscoreItem> highscoreListe;
	
	highscoreListe.push_back( HighscoreItem("Name 1",1000) );
	highscoreListe.push_back( HighscoreItem("Name 2",2000) );
	highscoreListe.push_back( HighscoreItem("Name 3",3000) );
	highscoreListe.push_back( HighscoreItem("Name 4",4000) );
	highscoreListe.push_back( HighscoreItem("Name 5",5000) );
	highscoreListe.push_back( HighscoreItem("Name 6",6000) );

	write(highscoreListe, string("D:\\Highscore.dat") );

	highscoreListe.clear();

	highscoreListe= read( string("D:\\Highscore.dat") );

	return 0;
}

Projekt wurde mit VisualStudio 2010 Express erstellt.
Projekt-Erstellung:
- Win32-Konsolenanwendung
- keine Vorkompilierter Header
- kein Leeres Projekt

Wenn Fragen... fragen!!