This is basically due to function call overhead and indirection. The ofstream::write() method is inherited from ostream. That function is not inlined in libstdc++, which is the first source of overhead. Then ostream::write() has to call rdbuf()->sputn() to do the actual writing, which is a virtual function call. On top of that, libstdc++ redirects sputn() … Read more
You are falling foul of a restriction upon the intermixing of read and write operations on a file opened in update mode that MS’s fstream library inherits from from the its C <stdio.h> implementation. The C Standard (I cite C99, but it doesn’t differ in this point from C89) at 7.19.5.3/6 states: When a file … Read more
The failbit is designed to allow the stream to report that some operation failed to complete successfully. This includes errors such as failing to open the file, trying to read data that doesn’t exist, and trying to read data of the wrong type. The particular case you’re asking about is reprinted here: char buffer[10]; stream.read(buffer, … Read more
You cannot insert in the middle of the file. You have to copy the old file to a new file and insert whatever you want in the middle during copying to the new file. Otherwise, if you intend to overwrite data/lines in the existing file, that is possible by using std::ostream::seekp() to identify the position … Read more
I think the previous answers are misleading. fstream is a proper RAII object, it does close automatically at the end of the scope, and there is absolutely no need whatsoever to call close manually when closing at the end of the scope is sufficient. In particular, it’s not a “best practice” and it’s not necessary … Read more
You can go the other way: implement your own stream buffer that wraps a file descriptor and then use it with iostream instead of fstream. Using Boost.Iostreams can make the task easier. Non-portable gcc solution is: #include <ext/stdio_filebuf.h> { int fd = …; __gnu_cxx::stdio_filebuf<char> fd_file_buf{fd, std::ios_base::out | std::ios_base::binary}; std::ostream fd_stream{&fd_file_buf}; // Write into fd_stream. // … Read more
It’s the other way around. When ios::ate is set, the initial position will be the end of the file, but you are free to seek thereafter. When ios::app is set, all output operations are performed at the end of the file. Since all writes are implicitly preceded by seeks, there is no way to write … Read more
The loop is incorrect as when eof() is encountered tellg() returns -1 and there is no check for eof() immediately after the call to getline() which there needs to be. Change loop to: while (getline(ifs, log)) { cout << log << endl; p = ifs.tellg(); } Additionally, as p is declared as a size_t when … Read more
You can open the file using the ios::ate flag (and ios::binary flag), so the tellg() function will give you directly the file size: ifstream file( “example.txt”, ios::binary | ios::ate); return file.tellg();
You’re specifying std::fstream::in in your call to fstream::open(). This is known to force it to require an existing file. Either remove std::fstream::in from your mode argument, or specify std::fstream::trunc in addition to the other flags.