Why did getline not reach the end of the file in C++? - c++

Question

I have a simple function that edits an HTML file. All it does is just to replace some texts in the file. This is the code for the function:
void edit_file(char* data1, char* data1_token, char* data2, char* data2_token) {
std::ifstream filein("datafile.html");
std::ofstream fileout("temp.html");
std::string line;
//bool found = false;
while(std::getline(filein, line))
{
std::size_t for_data1 = line.find(data1_token);
std::size_t for_data2 = line.find(data2_token);
if (for_data1 != std::string::npos) {
line.replace(for_data1, 11, data1);
}
if (for_data2 != std::string::npos) {
line.replace(for_data2, 19, data2);
}
fileout<<line;
}
filein.close();
fileout.close();
}
void edit_file_and_copy_back(char* data1, char* data1_token, char* data2, char* data2_token)
{
edit_file(data1, data1_token, data2, data2_token);
MoveFileEx("temp.html", "datafile.html", MOVEFILE_REPLACE_EXISTING);
}
For some reasons, I will call this function multiple times, but this function only works for the first time, and later on the "getline" it will stop somewhere in the middle of the file.
The replace function works without any problems (because it works the first time). However, the second time, the while loop will end after just reading some lines.
I have tried filein.close() or file.seekg function, but neither of them fix the problem. What causes the incorrect execution and how do to solve it?

Answer 1

Buffering is biting you. Here's what you're doing:
Opening datafile.html for read and temp.html for write
Copying lines from datafile.html to temp.html
When you're done, without closing or flushing temp.html, you open a separate handle to temp.html for read (which won't share the buffer with the original handle, so unflushed data isn't seen)
You open a separate handle to datafile.html for write, and copying from the second temp.html handle to the new datafile.html handle
But the copy in steps 3 & 4 is missing the data still in the buffer for temp.html opened in step 1. And each time you call this, if the input and output buffer sizes don't match, or the iostream implementation you're using doesn't flush until you write buffer size + 1 bytes, you'll drop up to another buffer size worth of data.
Change your code so the scope of the original handles ends before you call the copy back function:
void edit_file(char* data1, char* data1_token, char* data2, char* data2_token) {
{ // New scope; when it ends, files are closed
ifstream filein("datafile.html");
ofstream fileout("temp.html");
string strTemp;
std::string line;
//bool found = false;
while(std::getline(filein, line))
{
std::size_t for_data1 = line.find(data1_token);
std::size_t for_data2 = line.find(data2_token);
if (for_data1 != std::string::npos) {
line.replace(for_data1, 11, data1);
}
if (for_data2 != std::string::npos) {
line.replace(for_data2, 19, data2);
}
fileout<<line;
}
} // End of new scope, files closed at this point
write_back_file();
}
void write_back_file() {
ifstream filein("temp.html");
ofstream fileout("datafile.html");
fileout<<filein.rdbuf();
}
Mind you, this still has potential errors; if both data tokens are found, and data1_token occurs before data2_token, the index for data2_token will be stale when you use it; you need to delay the scan for data2_token until after you scan and replace data1_token (or if the data1_token replacement might create a data2_token that shouldn't be replaced, you'll need to compare the hit indices and perform the replacement for the later hit first, so the earlier index remains valid).
Similarly, from a performance and atomicity perspective, you probably don't want to copy from temp.html back to datafile.html; other threads and processes would be able to see the incomplete datafile.html in that case, rather than seeing the old version atomically replaced with the new version. It also means you need to worry about removing temp.html at some point. Typically, you just move the temporary file over the original file:
rename("temp.html", "datafile.html");
If you're on Windows, that won't work atomically to replace an existing file; you'd need to use MoveFileEx to force replacing of existing files:
MoveFileEx("temp.html", "datafile.html", MOVEFILE_REPLACE_EXISTING);

Answer 2

void edit_file(char* data1, char* data1_token, char* data2, char* data2_token) {
ifstream filein("datafile.html");
ofstream fileout("temp.html");
// STUFF
// At this point the two streams are still open and
// may not have been flushed to the file system.
// You now call this function.
write_back_file();
}
void write_back_file() {
// You are opening files that are already open.
// Do not think there are any guarantees about the content at this point.
// So what is copied is questionable.
ifstream filein("temp.html");
ofstream fileout("datafile.html");
fileout<<filein.rdbuf();
}
Do not call write_back_file() from within edit_file(). Rather provide a wrapper that calls both.
void edit_file_and_copy_back(char* data1, char* data1_token, char* data2, char* data2_token)
{
edit_file(data1, data1_token, data2, data2_token);
write_back_file();
}