#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() {
	string s;
	fstream fs( "D:\\test.txt", ios::in | ios::out );
	fs >> s;
	cout << s;
	fs << "new string";
	fs.close();
	system( "pause" );
	return 0;
}

ISO/IEC 9899:1990 schrieb:

When a file is opened with update mode ('+' as the second or third character in the above list of mode argument values), both input and output may be performed on the associated stream. However, output shall not be directly followed by input without an intervening call to the fflush function or to a file positioning function (fseek, fsetpos,or rewind), and input shall not be directly followed by output without an intervening call to a file positioning function, unless the input operation encounters end-of-file. Opening (or creating) a text file with update mode may instead open (or create) a binary stream in some implementations.

Für kombinierte Lese/Schreibaktionen auf den selben Stream verweist der C++-Standard auf den C-Standard, und dieser sagte:

ISO/IEC 9899:1990 schrieb:

When a file is opened with update mode ('+' as the second or third character in the above list of mode argument values), both input and output may be performed on the associated stream. However, output shall not be directly followed by input without an intervening call to the fflush function or to a file positioning function (fseek, fsetpos,or rewind), and input shall not be directly followed by output without an intervening call to a file positioning function, unless the input operation encounters end-of-file. Opening (or creating) a text file with update mode may instead open (or create) a binary stream in some implementations.

ich glaub das was du meist ist, C type FILE, not C++, wenn ich mich da nicht taeusche,

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() {
	string s;
	fstream fs( "D:\\test.txt", ios::in | ios::out );
	fs >> s;
	cout << s;
	fs.flush();
	fs << "new string";
	fs.close();
	system( "pause" );
	return 0;
}

so funktioniert es auch nicht

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() 
{
    string s;
    fstream fs( "D:\\test.txt", ios::in | ios::out );
    fs >> s;
    cout << s << '\n';
    fs.seekp(0, std::ios_base::end);
    fs << "new string\n";
    return 0;
}

Und das oben zitierte gilt auch für std::fstream . Wie gesagt, der C++-Standard verweist an der Stelle auf den C-Standard.

Probiers mal so:

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() 
{
    string s;
    fstream fs( "D:\\test.txt", ios::in | ios::out );
    fs >> s;
    cout << s << '\n';
    fs.seekp(0, std::ios_base::end);
    fs << "new string\n";
    return 0;
}

Und das oben zitierte gilt auch für std::fstream . Wie gesagt, der C++-Standard verweist an der Stelle auf den C-Standard.

geht net, funz nicht, wird nix geschrieben

[...]

Hmm, bei mir geht geht das. Vor Programmaufruf in test.txt:
Hallo

Nach Programmaufruf in test.txt:
`Hallo

new string`

Ausgabe:
Hallo

Hast du denn d:\test.txt schon erstellt und steht da auch artig was drin?

Im Moment sieht es so aus, dass der von Tachyon gepostete Code genau das macht, was er tun sollte. Wenn du also nicht mehr sagst als "geht nicht", kann ich dir nicht weiterhelfen.

Findest du nicht, dass "geht net, funz nicht, wird nix geschrieben" ziemlich ungenau ist? Was machst du genau? Wie sehen die Vorbedingungen aus? Meldet der Compiler was? Was steht in der Datei?

Im Moment sieht es so aus, dass der von Tachyon gepostete Code genau das macht, was er tun sollte. Wenn du also nicht mehr sagst als "geht nicht", kann ich dir nicht weiterhelfen.

in der textdatei steht irgendein beispiel text, mein eigentlichen vorhaben is ein text auslesen und inhalt veraendern und wieder in die textdatei schreiben, jedoch funktioniert das schreiben nicht, und das ist mein problem.

es wird richtig compiliert und kein fehler wird produziert, nur die textdatei wird ueberhaupt nix veraendert, ( also keine neuen inhalt reingeschrieben ).

ist es soweit verstaendlich??

#include <fstream>

fstream file;
file.open (myPath.c_str(), ios::in | ios::out | ios::binary);

string sLine;

//configdatei zeilenweise einlesen
while(getline(file, sLine))
{
   //Änderungen machen in der richtigen Zeile
}

//das funktioniert beides nicht
file.flush();
file.seekp(0, std::ios_base::end); 

//datei schreiben hier soll jetzt einfach nur mal test rein
file.write ("test",4);
file.close();
	}

#include<fstream>
#include<iostream>

using namespace std;

// Lesen und Schreiben auf *einer* Datei

int main() {
    // Datei anlegen
    fstream filestream("fstream2.dat", ios::out | ios::trunc);
    filestream.close();            // leere Datei existiert jetzt
    int i;                 // Hilfsvariable

    // Datei zum Lesen und Schreiben öffnen
    filestream.open("fstream2.dat", ios::in | ios::out);
    // schreiben
    for(i = 0; i < 20; ++i) {
      filestream << i << ' ';         // kein EOF direkt nach der letzten Zahl
    }
    filestream << endl;

    // lesen
    filestream.seekg(0);               // Anfang suchen
    while(filestream.good()) {
       filestream >> i;                // lesen
       if(filestream.good()) {
          cout << i << ' ';    // Kontrollausgabe
       }
       else {
          cout << endl << "Dateiende erreicht (oder Lesefehler)";
       }
    }
    cout << endl;
    filestream.clear();                // EOF-Status löschen
    filestream.seekp(5);               // Position 5 suchen

    filestream << "neuer Text ";       // ab Pos. 5 überschreiben
    filestream.seekg(0);               // Anfang suchen
    char buf[100];
    filestream.getline(buf,100);       // Zeile lesen
    cout << buf << endl;       // Kontrollausgabe
}

Statt trunc kann man auch app nehmen, wenn die datei nicht geleert werden soll.
Ausgabe des Programms:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 
Dateiende erreicht (oder Lesefehler)
0 1 2neuer Text 8 9 10 11 12 13 14 15 16 17 18 19

Man beachte das mittenrein geschriebene "neuerText".

filestream.clear();

file.flush() macht wohl nicht das gleiche wie fflush() wie es weiter oben in der Beschreibung stand. fflush() geht hier aber auch nicht, das erwartet einen pointer auf ein file und keinen fstream.

Statt open() kannst du gleich den Konstruktor verwenden. close() brauchst du nicht, das geschieht im Destruktor. Und generell würde ich nicht binäres und textuelles Lesen/Schreiben in der selben Datei mischen.