7 
class Person {
private:
    string firstName;
    string lastName;
public:
    Person() {}

    Person(ifstream &fin) {
       fin >> firstName >> lastName;
    }

    void print() {
       cout << firstName
           << " "
           << lastName
           << endl;
    }
};

int main() {
    vector<Person> v;
    ifstream fin("people.txt");

    while (true) {
        Person p(fin);
        if (fin == NULL) { break; }
        v.push_back(p);
    }

    for (size_t i = 0; i < v.size(); i++) {
       v[i].print();
    }

    fin.close();
    return 0;
}

Please can you explain me, how following code snippet works? if (fin == NULL) { break; }

fin is a object on stack, not a pointer so it can not become NULL. I was unable to find overloaded operator== function in ifstream class. So I can not understand how this snippet works.

Improve this question

3 Answers 3

Reset to default
5

The ifstream class has an operator void *() (or operator bool() in C++11). This is what is called when you test (fin == NULL).

Testing fin == NULL should be exactly the same as testing fin.fail().

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thank you very much. Your answer was very helpful.
3

The base classes of istream and ostream have implicit conversion functions, which allow them to be used as a boolean value; in pre-C++11, the implicit conversion was to void*.

It was never the intent that the result of this conversion be used as a pointer, and code like fin == NULL shows an extremely poor understanding of C++ and the standard streams. The idiomatic way of writing the first loop would be to define a default constructor and an operator>> for Person, and then write: 

Person p;
while ( fin >> p ) {
    v.push_back( p );
}

(And while I'm at it: you really should test the return value of fin.close(), and not return 0 if it fails:

fin.close();
return fin ? EXIT_SUCCESS : EXIT_FAILURE;

.)

Improve this answer

6 Comments

While I agree that it would probably best practice to do it, I’ve never seen code that tests whether closing was successful, and adjusting the return value. Personally, I never call close anyway, relying on RAII instead – but luckily I can get away with writing code that doesn’t do robust IO.
@KonradRudolph: I guess relying on RAII implies that the destructor doesn't tests whether closing was successful either. There are no means to transport such an error condition to the caller (unless you resort to global variables).
@Frerich Of course. Like I said, I can get away with doing non-robust IO. Lazy, I know, but it makes the code much simpler and cleaner.
@KonradRudolph I've never written code that doesn't either flush and check (if output is std::cout) or close and check. I would consider not doing so a serious error. A frequent idiom for using a program is something like: prog filename > tmp && mv tmp filename. If you return a successful status when you haven't actually successfully written the data, users are not going to be happy.
@James I’d agree – if had ever observed this problem. As it is, I’ve never (ever) had any problems with IO except of course when using a removable device (and removing it mid-read) or similar shenanigans. Of course this breaks down once you start working with large files, have disk quotas or …. But for my simple needs it was enough. But I certainly wouldn’t advice this kamikaze style of programming.
|
2

This isn’t how streams are supposed to be used. True, this (unfortunately!) compiles and even does the “right” thing. But don’t write code like this. Whoever wrote this code probably thought they were clever.

But what they really did was break the expectations of C++ programmers by introducing a new, unconventional API, with no real advantages.

This code initialises an object of type Person from an input stream. Unfortunately, by doing this, the code forgoes the opportunity to test for errors while reading the object. This isn’t good. An object should not have a constructor accepting an input stream, it should overload operator>>.

Improve this answer

2 Comments

Playing the devils advocate here: I think that passing a stream to a constructor makes perfect sense. You can use exceptions to signal errors, and you avoid the problem of having the possibility of uninitialized objects (unlike with your suggested alternative, which allows constructing an object but not using operator>>).
@Frerich In principle, I entirely agree with you. That’s also why I said that this was a programmer being clever, rather than James who thought it was somebody who’s clueless about streams. But it still breaks expectations and is probably not a good idea in C++ building on top off the existing stream library. Streams could be done much better, but then build an own library, don’t build on top of an existing pattern which works differently.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.