Question

I have a program that load data from a file using std::ifstream and store the data in a structure. After that, I verify if the data I want was in the file. If it is not, I ask the user to modify the file and press a key. I then reload the file. The problem is that even if the user modified the file, I always get the same data in the file because the file seems to be cache in the application. I’ve seen that in win32 API, it’s possible to use the flag FILE_FLAG_NO_BUFFERING to avoid using a buffered copy when reading a file, but I would like to use that feature with std::ifstream. Is there any way to use the handle created through win32 api with ifstream or anyway to force it directly in std::ifstream ?

Here’s a “simplified” code sample:

SomeStructure  s = LoadData(fileName);
while(!DataValid(s))
    s = LoadData(fileName);


SomeStructure LoadData(const std::string& fileName)
{
    std::ifstream fileStream;
    while(!OpenFileRead(fileName, fileStream))
    {
        std::cout<<"File not found, please update it";
        fileStream.close();
        //Wait for use input
        std::string dummy;
        std::getline(std::cin, dummy);
    }
    //... Read file, fill structure, and return
    std::string line;   
    while(std::getline(fileStream, line) && line!="")
    {
        //At this point, I can see that line is wrong
        StringArray namedatearray=Utils::String::Split(line, "|");
        assert(namedatearray.size()==2);
        //Add data to my structure ( a map)
     }
     fileStream.close();
     //return structure
}

bool OpenFileRead(const std::string& name, std::fstream& file)
{    
    file.open(name.c_str(), std::ios::in);
    return !file.fail();
}

Thanks.

Edit: Of course, it was a mistake because I had two time the same file in two very similar path. Looking at the handle of the file open with process explorer (and not the relative file path made me found it).

Answer 1

Instead of thinking that this is due to some kind of “buffering”, I would look for the obvious things first.

• Are you sure the user is changing the same file that you’re reading?
• Are you certain reloading the data is properly updating your data structure in memory?
• Are you confident that DataValid() is doing what you want?

The fact that the OS uses file buffers to increase disk performance is generally not visible from the application level. As long as you’re looking at the same file, the OS knows that the user updated the file, and if you reopen it, then you’ll see the changed data. If the data never even had a chance to get flushed to disk, that won’t affect your application.