ZFX + Developia

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

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

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

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

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

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

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

Code: Alles auswählen

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

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

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

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