Nicolai Josuttis says in his book that the open member function doesn't clear the state flags. That's not what I found in VS2010. Is this a MS issue?

Question

Nicolai Josuttis in page 547 of his book "The C++ Standard Library" says the following in relation to the code below :

Note that after the processing of a file, clear() must be called to clear the state flags that are set at end-of-file. This is required because the stream object is used for multiple files. The member function open() does not clear the state flags. open() never clears any state flags. Thus, if a stream was not in a good state, after closing and reopening it you still have to call clear() to get to a good state. This is also the case, if you open a different file.

// header files for file I/O
#include <fstream>
#include <iostream>
using namespace std;
/* for all file names passed as command-line arguments
* - open, print contents, and close file
*/
int main (int argc, char* argv[])
{
    ifstream file;
    // for all command-line arguments
    for (int i=1; i<argc; ++i) {
        // open file
        file.open(argv[i]);
        // write file contents to cout
        char c;
        while (file.get(c)) {
            cout.put(c);
        }
        // clear eofbit and failbit set due to end-of-file
        file.clear();
        // close file
        file.close();
    }
}

My code below works without a problem in VS2010. Note that after the file "data.txt" is created, it's read twice without clearing the input stream flags.

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

int main()
{
    //  Create file "data.txt" for writing, write 4 lines into the file and close the file.

    std::ofstream out("data.txt");
    out << "Line 1" << '\n' << "Line 2" << '\n' << "Line 3" << '\n' << "Line 4" << '\n';
    out.close();

    //  Open the file "data.txt" for reading and write file contents to cout

    std::ifstream in("data.txt");
    std::string s;
    while( std::getline(in, s) ) std::cout << s << '\n';
    std::cout << '\n';
    std::cout << std::boolalpha << "ifstream.eof() before close - " << in.eof() << '\n';

    //  Close the file without clearing its flags

    in.close();
    std::cout << std::boolalpha << "ifstream.eof() after close - " << in.eof() << '\n';

    //  Open the file "data.txt" again for reading

    in.open("data.txt");
    std::cout << std::boolalpha << "ifstream.good() after open - " << in.good() << '\n';
    std::cout << '\n';

    //  Read and print the file contents

    while( std::getline(in, s) ) std::cout << s << '\n';
    std::cout << '\n';
}

Ouput

Answer 1

That was changed for C++11. The C++98 rule (as correctly described by Josuttis) was clearly wrong, so I wouldn't be surprised if implementations didn't honor it.