ich habe folgendes Problem: Ich habe ein ini-File, in welchem Daten zur Initialisierung stehen oder (bei der ersten Nutzung meines Programms) eben noch nichts.
Beim Öffnen eines Dialogs lese ich also aus diesem File aus und schreibe, sollten neue Einstellungen gespeichert werden müssen, diese dort hinein. Dafür benutze ich fstream. Das Auslesen funktioniert auch wunderbar, trage ich händisch etwas in meine Datei ein, liest er es ohne Probleme aus, was mir eine Konsolenausgabe bestätigt.
Probleme habe ich nur beim hineinschreiben, was aus irgendeinem Grund nicht funktioniert. Überprüfe ich den return-Wert der Funktion oder fange die Exception ab, erhalte ich die Information, dass das failbit gesetzt ist.
Ich hab allerdings (da auch nicht gerade bewandert auf diesem Gebiet) keine Ahnung, woran das liegen könnte.

Hier mal mein Code:

fstream fp;

fp.open(iniFile, fstream::in|fstream::out);
while(fp.good()){
  fp.exceptions(fstream::failbit);
  if(fp.peek()!=EOF){
    //File not empty, doing some sorting stuff...
  }
  else{
    fp.seekg(ios::beg);
    try{
      fp.write(ProjName, sizeof(ProjName));    /* ProjName ist ein std::string, der übergeben wird */
    }
    catch(fstream::failure f){
      cout << "Writing in file: failbit set" << endl;
    }
  }
}

Das ist es im Großen und Ganzen. Den Sortieralgorithmus für den Fall, dass schon etwas im File steht, habe ich einmal weggelassen, da dieser tadellos funktioniert, außer, dass die einzelnen Zeilen nicht in meine Datei geschrieben werden. Das Problem ist also vorhanden, ob File leer oder nicht.

Was übersehe ich oder mache ich falsch?

Kurz: Gib mal ein vollständiges, compilierbares Beispiel, bei dem du bis auf den fehlerverursachenden Code alles überflüssige rausgekürzt hast, gegebenenfalls gib noch den Dateiinhalt. Und dann beschreib genau, welche Handlungen zum Fehler führen.

Du solltest auch mal mit dem Debugger Zeile für Zeile durchgehen und gucken, an welcher Stelle das Programm von dem von dir erwarteten Verhalten abweicht. Dadurch kannst du das Problem dann vermutlich auch alleine lösen.

Und beschreib auch mal, was dein Programm genau machen soll. Was soll es erreichen, nicht das Wie! Deine Lösung sieht schon etwas ungewöhnlich aus, kann je nach Ziel aber auch ein guter Weg sein. Wieder die Frage, ob Versehen oder bewusste Entscheidung.

Da ich zum ersten Mal mit fstream arbeite, ist mir da auch so einiges nicht klar. Zum Beispiel, ob ich nach dem Auslesen (wie mit Filepointern in C) wieder an die erste Stelle in der Datei muss. Vielleicht hakts ja daran, obwohl es beim write() keinen Unterschied zu machen scheint, ob ich vorher den Anfang der Datei suche oder nicht.

Nun ja, das Beispiel:

#define iniFile "inifile.txt"

void setRecentProjects(string ProjName){
 /* Check if file is empty and if project already exists */
 fstream fp;
 bool sort = false;
 int existing = 0;
 int index = 0;
 char compare[5][255];
 char buf[5][255];

 fp.open(iniFile, fstream::in|fstream::out);
 while(fp.good()){
  fp.exceptions(fstream::failbit);
  if(fp.peek()!=EOF){
   fp.getline(compare[index], 255, '\n'); 
   cout << "compare: " << compare[index] << " ProjName: " << ProjName << endl;
   if( (strcmp(compare[index], ProjName)==0) && index>0 ){
    existing = index;
    cout << " The same, to be sorted " << existing << endl;
    strcpy(buf[0], compare[existing]);

    for(int c=0;c<existing;c++){
     strcpy(buf[c+1], compare[c]);
    }
    for(int c=existing; c<index;c++){
     strcpy(buf[c], compare[c]);
    }
    for(int c=0;c<index;c++){
     cout << endl << buf[c] << endl;
     try{
      fp.seekg(ios::beg);
      fp.write(buf[c],sizeof(buf[c]));		//does not write: fail
      fp.write("\n", sizeof(char));
     }
     catch(fstream::failure f){
      cout << "failure writing in file" << endl;
     }
    }
   }
   else if( (strcmp(compare[index], ProjName)==0) && index==0 ){
    cout << " The same, first place" << endl;
   }
   index++;
  }
  else{		//file is empty
   //filepointer to beginning
   fp.seekg(ios::beg);
   cout << "File is empty" << endl;
   cout << ProjName << endl;
   try{
    fp.write(ProjName, sizeof(&ProjName));
    fp.write("\n", sizeof(char));
   }
   catch(fstream::failure f){
    cout << "failure writing in file" << endl;
   }
  }
 }
 fp.close();
}

int main(){
 setRecentProjects("test1");

 return 0;
}

Schön ist der Code leider nicht, nachdem ich auch sicher fünfhundertmal darin rumgepfuscht habe, um zu sehen, ob es irgendwie anders funktioniert. Ich hoffe, man kann wenigstens erahnen, was dort passieren soll. Optimiert wird, wenns läuft...

Edit: Ich befürchte fast, dass besagte Entscheidungen von mir eher versehentlich getroffen wurden

Warum fuchtelst du mit C-Strings rum und nutzt nicht std::string? Damit hättest du schon mal eine Fehlerquelle mehr ausgeschlossen und brauchst auch kein strcmp mehr verwenden. Für Arrays kannst du dann noch std::vector nehmen, womit sich auch einfach eine Sortierfunktion realisieren lässt, was eine weitere Fehlerquelle beseitigt.

Anscheinend handelt es sich um keine Binärdatei, also brauchst du write gar nicht benutzen sondern kannst mit dem Operator >> in die Datei schreiben. Übrigens brauchst du die Datei gar nicht mit close manuell zu schließen. Das erleigt der Destruktor automatisch.

Wenn ich durch deinen Code durchsteigen würde, dann hätte ich dir kurz ein Beispiel gemacht.

Meinst du es so?

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

typedef std::vector<std::string> StrVec;

const std::string INI_FILE = "inifile.txt";

bool setRecentProjects(std::string ProjName)
{
	StrVec vec;

	std::ifstream ifst(INI_FILE);

	if (ifst.good())
	{
		std::string line;

		while (std::getline(ifst, line))
		{
			vec.push_back(line);
		}

		ifst.close();
	}

	for (StrVec::iterator it = vec.begin(); it != vec.end();)
	{
		if (*it == ProjName)
		{
			it = vec.erase(it);
		}
		else
		{
			++it;
		}
	}

	vec.push_back(ProjName);

	std::ofstream ofst(INI_FILE, std::ios::trunc);

	if (!ofst.good())
		return false;

	std::sort(vec.begin(), vec.end());

	for (StrVec::iterator it = vec.begin(); it != vec.end(); ++it)
	{
		ofst << *it << "\n";
	}

	return true;
}

int main()
{
	if (!setRecentProjects("test"))
		std::cerr << "Error\n";

	if (!setRecentProjects("test"))
		std::cerr << "Error\n";

	if (!setRecentProjects("test2"))
		std::cerr << "Error\n";

	if (!setRecentProjects("z"))
		std::cerr << "Error\n";

	if (!setRecentProjects("a"))
		std::cerr << "Error\n";

	if (!setRecentProjects("a"))
		std::cerr << "Error\n";

	return 0;
}

Abgesehen davon: Wie gesagt, die Sortierfunktion funktioniert ja soweit, das Problem ist immernoch das write(). Debuggen und Konsolenausgaben liefern mir zumindest keinen Hinweis darauf, dass es an dem Inhalt des Arrays scheitern würde.
Aber ändern kann ich das ja trotzdem

Edit: Durch dein Beispiel muss ich jetzt erstmal durchsteigen, aber danke!

Dieser wird durchlaufen und überprüft, ob ProjName bereits vorhanden ist. Wenn das der Fall ist, dann wird es aus dem std::vector gelöscht.

Anschließend wird ProjName dem std::vector hinzugefügt, da dieser nun definitiv noch nicht im std::vector vorhanden ist (entweder wurde er beim Durchlaufen gelöscht oder er war nie enthalten).

Der Inhalt des std::vector wird dann mit der Funktion std::sort sotiert und anschließend zeilenweise in die Datei zurückgeschrieben. Der Parameter std::trunc gibt dabei an, dass die Datei auf 0 Bytes zurückgesetzt werden soll und somit leer ist. Das bewirkt, dass die Datei überschrieben wird.

That's it!

Der Inhalt des std::vector wird dann mit der Funktion std::sort sotiert und anschließend zeilenweise in die Datei zurückgeschrieben. Der Parameter std::trunc gibt dabei an, dass die Datei auf 0 Bytes zurückgesetzt werden soll und somit leer ist. Das bewirkt, dass die Datei überschrieben wird.

Das ist beim Rundum-Sorglos-Paket ofstream schon implizit mit drin. Ich bin mir gerade aber nicht so sicher, ob das gut geht, da die Datei ja noch vom Lesen offen ist. Setz doch sicherheitshalber noch einen Scope um das Einlesen. (P.S.: Sehe gerade, dass du die Datei explizit schließt. Somit ist das natürlich in Ordnung so)

Und das if(ifst.good()) kann man sich auch sparen, da dies ja schon von der while-Schleife erledigt wird.

Ich bin übrigens kein Fan von der Idee, die Datei zu überschreiben. Ich würde eine temporäre Datei schreiben und dann die Namen vertauschen. Dann ist im Falle eines ungünstigen Stromausfalls nicht alles weg.

Jetzt gehts, Problem solved