Fstream: Variable in Datei schreiben?



  • Hallo Cpp Gemeinde!

    Ich wollte mal fragen wie man eine Variable in eine Datei schreiben kann?
    Bei:

    Save >> LV >> skipline;
    

    Code vom skipline:

    std::istream& skipline( std::istream& in )
    {
        return in.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
    }
    

    Das Problem dabei ist, dass die Datei geleert wird, und leer bleibt - warum?



  • Was für eine Variable willst du in die Datei schreiben? Was hat ein skipline-Manipulator mit "in Datei schreiben" zu tun? Warum sind dort überhaupt Input-Operatoren, wenn du schreiben willst?

    Bitte formuliere dein Problem vernünftig. Erkläre, was du tun willst, und nicht wie.



  • Was versuchst du denn mit skipline zu machen?

    Möchtest du an das Ende der Datei schreiben?.
    Dann schau dir die openmodes an. Eine schnelle Referenz:
    http://www.cplusplus.com/reference/ios/ios_base/openmode/

    std::ofstream(fileName, std::ios_base::ate); // villeicht auch std::ios_base::binary? oder gar ios_base::app?
    

    Ansonsten, müsste ich raten.



  • Also ich will eine string-Variable in die Datei schreiben, mit Skipline will ich einfach nur ein "<< endl" bewirken, mit '\n' passiert irgendwie nichts, der schreibt trotzdem in einer Zeile. 😕
    Sorry für die Unvollständigkeit.



  • Dafuer brauchst du einen output-Stream.



  • std::ofstream // zum schreiben (output file stream)
    std::ifstream // zum lesen (input file stream)
    std::fstream // kann zum lesen und / oder schreiben verwendet werden. Ich persönlich brauche den fstream eigentlich kaum.
    
    // std::ofstream file (DATEIPFAD, OPTIONEN); // öffnet die datei automatisch. Beispiel:
    std::ofstream file ("./my_save.txt", std::ios_base::binary);
    
    if (!file.good()) // ist die datei nun offen?
    {
        std::cerr << "oh crap cannot open / create this file!"; // hier wohl nicht :(
    }
    
    // schreibe variable & newline
    std::string text = "hello";
    file << text << '\n';
    
    // schreibe ein Zeichen
    file.put('A');
    
    // file.write(buffer, amount); // hiermit kannst du mehrere bytes beliebigen formats in die datei schreiben
    
    // file.tellp(); // wie viel habe ich bis jetzt geschrieben?
    
    // file.close(); //NICHT NOETIG! Außer du möchtest nun anderweitig auf die Datei zugriffen (ohne, dass file zuvor zerstört wird)
    

    Damit kann man erstmal was anfangen weitere informationen findest du zum Beispiel hier:
    http://www.cplusplus.com/reference/fstream/ofstream/



  • Hallo Shortyoo,

    guckst Du hier: http://www.c-plusplus.net/forum/323453



  • Ouh bin ich dumm. 😃

    Sorry, hatte einfach nur die Pfeile in der falschen Richtung gehabt.^^

    Danke an alle! 🙂



  • Und ein paar O's durch I's getauscht 😉



  • Oder du verwendest statt std::ofstream fprintf. Die Funktion arbeitet mit FILE* zusammen. Wenn du magst, kannst du den folgenden Code gerne verwenden..

    #include <Windows.h>
    #include <iostream>
    
    namespace Log
    {
    	extern bool Create( std::string szFile );
    	extern void add( const char* fmt, ... );
    };
    
    namespace Log
    {
    	bool bInitialize = false;
    	std::string	szFileName = "";
    
    	bool Create( std::string szFile )
    	{
    		if( !( char* )szFile.c_str() )
    		return false;
    
    		szFileName = szFile;
    
    		FILE*	f;
    
    		if( ( f = fopen( ( char* )szFileName.c_str(), "a" ) ) != NULL )
    		{
    			fclose( f );
    			bInitialize = true;
    		}
    		return bInitialize;
    	}
    	void add( const char* fmt, ... )
    	{
    		if( !bInitialize )
    			return;
    
    		char	Buffer[ 2048 ];
    		FILE*	f;
    		va_list	args;
    
    		va_start( args, fmt );
    		vsprintf_s( Buffer, fmt, args );
    		va_end( args );
    
    		if( ( f = fopen( ( char* )szFileName.c_str(), "a" ) ) != NULL )
    		{
    			fprintf( f, "%s\n", Buffer );
    			fclose( f );
    		}
    	}
    }
    


  • Das ist aber nicht wirklich empfehlenswert, char-Arrays, File* und fprintf sind C.



  • duplex0 schrieb:

    Oder du verwendest statt std::ofstream fprintf. Die Funktion arbeitet mit FILE* zusammen. Wenn du magst, kannst du den folgenden Code gerne verwenden..

    namespace Log
    {
    
    ... // jede Menge Schrott
    }
    

    Also mir wird richtig schlecht, wenn ich so was sehe. Beispielsweise:

    if( !( char* )szFile.c_str() )
    		return false;
    

    szFile.c_str() liefert nie einen 0-String zurück. Und überhaupt sollte man das const nie weg casten, auch wenn es hier ungefährlich ist, aber offensichtlich hast Du keine Ahnung von const. Oder:

    char	Buffer[ 2048 ];
    

    Das ist der Stoff aus dem die Sicherheitslücken über Buffer overflows sind und damit auch der schlechte Ruf von C und C++ ist. Solche festen Puffer muss man gerade in C++ gar nicht verwenden und so wie es hier dargestellt ist schon gar nicht.

    Mehr will ich hier gar nicht kommentieren



  • die variadischen parameter und die fehlende typensicherheit sowie die fehlende möglichkeit, die ausgabe auf eigene typen zu erweitern muss man sich erst einmal auf der zunge zergehen lassen.


Log in to reply