Hab ein Problem mit folgendem code:

fstream	flField;

flField.open("field.cfg", fstream::in); //try opening file for reading
if( !flField.is_open() )  // if its not there ->
{
	flField.open("field.cfg", fstream::trunc | fstream::out); // create it for writing and
	// line below worked with ofstream but not with fstream
	flField << "size (400,300)" << endl << "bot (200,150)" << endl << "wall (0,0)(50,0)(50,50)(0,50)" << endl; // write example

	flField.close(); // close it and
	flField.open("field.cfg", fstream::in); // reopen it for reading
}

// line below is false if file has just been created via ofstream (see above)
while(flField.good())

Danke im Voraus.

Gruß hase

Hallo zusammen.

Hab ein Problem mit folgendem code:

fstream	flField;
 
flField.open("field.cfg", fstream::in); //probier hier mal ios::in oder verwende gleich std::ifstream
if( !flField.is_open() )  // if its not there ->
{
	flField.open("field.cfg", fstream::trunc | fstream::out); // create it for writing and
	// line below worked with ofstream but not with fstream
	flField << "size (400,300)" << endl << "bot (200,150)" << endl << "wall (0,0)(50,0)(50,50)(0,50)" << endl; // write example
 
	flField.close(); // close it and
	flField.open("field.cfg", fstream::in); // reopen it for reading
}
 
// line below is false if file has just been created via ofstream (see above)
while(flField.good())

Danke im Voraus.

Gruß hase

Siehe Kommentar im Text.

while(flField.good())

Was soll das denn werden? Nachdem du die datei geschrieben hast, schließt du sie, hast du je gemacht. Dann öffnest du sie und musst natürlich auch einen Container haben oder Datentypen wo du es reinlesen kannst.

Siehe Kommentar im Text.

äh... ja. die Kommentare sind von mir...

flField.open("field.cfg", fstream::trunc | fstream::out);

ich dachte fstream kann sowohl daten einlesen(in) als auch schreiben(out).
Hier will ich eine Datei anlegen(trunc) und so öffnen, dass ich was rein schreiben kann.

Firefighter schrieb:

while(flField.good())

Was soll das denn werden?

Ich dachte es wäre klar, dass da ne Schleife kommt, mit der ich was aus der File lese und nach deren Durchlauf ich prüfe, ob ich noch weiter daraus lesen kann(eof/fail/bad).

Firefighter schrieb:

Nachdem du die datei geschrieben hast, schließt du sie, hast du je gemacht.

raff ich net...
achsooo... ja ich öffne sie zuerst zum schreiben(out), schließe sie dann wieder, um sie danach zum lesen(in) zu öffnen.
Dachte ich hätte das als Kommentare dazu geschrieben.

Firefighter schrieb:

Dann öffnest du sie und musst natürlich auch einen Container haben oder Datentypen wo du es reinlesen kannst.

ich glaub das hab ich oben geklärt.

Nur wegen meinem Namen und der geringen Anzahl Posts bin ich kein c++ Neuling...
sorry für die zynische Art aber eigentlich dachte ich, ich hätte alles gut genug dargestellt. falls nicht wie gesagt sorry.

f.open(NAME, _ios_::in | ios::out | ios::trunc);

wobei sich einlesen und neu erstellen wieder spricht...
also in und out geht aber in und trunc glaub ich nicht...

und naja normal geht man die datei dann per eof schleife durch

while ( !f.eof() ) { }

Das mit dem schreiben der Datei sieht ja schon ganz gut aus, aber das lesen noch nicht so ganz,hier ein Beispiel.

#include<fstream>
#include<vector>

int main()
{
   std::ifstream datei("test.txt");//beim Lesen muss das ios::in Flag nicht explizit angegeben werden
   std::string aus_datei;
   std::vector<std::string> daten_vec;

   while(getline(datei,aus_datei))//hier wird Zeilenweise gelesen
   {
      daten_vec.push_back(aus_datei);//und hier werden die gelesenen Zeilen in einen vector gepackt
   } 
  return 0;
}

Ich weiß nicht ob es das ist was du willst, aber das ist einfaches Beispiel um eine Datei Zeilenweiße einzulesen.

while ( !f.eof() ) { }

Kann man machen, man hat dann aber das Problem das am Ende der Datei das LEtzte was drinne steht, 2mal ausgelesen wird

ifstream	flField;
	ofstream	flNew;

	flField.open("field.cfg");
	if( !flField.is_open() )
	{
		flNew.open("field.cfg"); // Datei anlegen und schreiben
		flNew << "size (400,300)" << endl << "bot (200,150)" << endl << "wall (0,0)(50,0)(50,50)(0,50)" << endl;
		flNew.close();

		flField.open("field.cfg");
		flField.is_open(); // is true
	}
	flField.eof(); // false
	flField.bad(); // false
	flField.fail(); // false wenn datei schon vorhanden war - true wenn garade erstellt

hier geht das schreiben, jedoch kann ich die Datei danach nicht einlesen( failbit ist in dem Fall gesetzt ).
Beende ich das Programm und starte es dann wieder mit vorhandener field.cfg geht es...

http://www.cplusplus.com/reference/ schrieb:

failbit is generally set by an input operation when the error was related with the internal logic of the operation itself

Versuch mal den Stream nach dem schreiben zu clearen "stream.clear();" und dann nochmal zu lesen.

Das wars! Danke!

ifstream    ifsField;
    ofstream    ofsNew;

    ifsField.open("field.cfg");
    if( !ifsField.is_open() )
    {
        ofsNew.open("field.cfg"); // Datei anlegen und schreiben
        ofsNew<< "size (400,300)" << endl << "bot (200,150)" << endl << "wall (0,0)(50,0)(50,50)(0,50)" << endl;
        ofsNew.close();

        ifsField.clear(); // <--- !!! clear errorflags
        ifsField.open("field.cfg");
        ifsField.is_open(); // true

        ifsField.eof(); // false
        ifsField.bad(); // false
        ifsField.fail(); // false (true wenn nicht clear() aufgerufen wurde !)
    }

Hab erwartet open() setzt die bits automatisch

jetzt weis ich was mit

#c++ schrieb:

fstreams behaviour is weird

gemeint ist xD

Firefighter schrieb:

Was mich aber sehr stark wundert, das du mit einem ifstream schreibst und aber nirgends liest. Der compiler müsste eigentlich einen Fehler melden.

ich schreib mit ofstream und lese mit ifstream später. hab die Variablen jetzt treffender benannt.

jetzt funktioniert das auch mit fstream :

fstream    fsField;

	fsField.open("field.cfg", fsField.in); //try opening file for reading
	if( !fsField.is_open() )  // if its not there ->
	{
		fsField.clear(); // <--- !!! clear errorflags
		fsField.open("field.cfg", fsField.trunc | fsField.out); // create it for writing and
		fsField << "size (400,300)" << endl << "bot (200,150)" << endl << "wall (0,0)(50,0)(50,50)(0,50)" << endl; // write example
		fsField.close(); // close it and
		fsField.open("field.cfg", fsField.in); // reopen it for reading
		fsField.good(); // true :D
	}

Dankeschön