Re: Trouble with eof()
Ulrich Eckhardt wrote:
Sherrie Laraurens wrote:
I'm having some difficulty understanding the difference in
interpratation of the fstream's eof() method.
I basically try and read a file in and count the number of
characters I read in, using the code in the main routine I
always get one more (count1) than the second count I get
from using the code in load file.
Even when the file is empty, the eof() for the first loop
round returns true, which i believe is somewhat incorrect.
void loadfile(const std::string& file_name, std::string& buffer)
{
std::ifstream file(file_name.c_str(), std::ios::binary);
if (!file) return;
buffer.assign(std::istreambuf_iterator <char>(file),
std::istreambuf_iterator <char>());
file.close();
}
Correct code, though there's no need for close()ing the
fstream
And how do you handle errors on the close. (Admittedly, for
input, there's not much chance of a new error occuring in the
close, so presumably, you could check before.)
and it lacks error-signalling. Other than that, take a look at
std::distance if you just need the length.
void main()
Please read the FAQ.
unsigned int count = 0;
while (!file.eof())
{
file.get();
count++;
}
Now, this code is broken. The point is that eof() only returns
true if (during some operation) the end of the file was
encountered, so you need to check between calling get() and
incrementing the counter. Alternatively, you could check the
returnvalue of get() whether it matches the eof value defined
in the char_traits (IIRC, need to look it up).
Idiomatic IOStream input then looks like this in C++:
while(true) {
in >> record;
if(in) {
handle(record);
continue;
}
Idiomatically, I'd say that as much as I dislike it in general,
this is one case where the update and the test are always
embedded:
while ( in >> record ) {
handle( record ) ;
}
if(in.eof())
// okay, reached end of file
Maybe. You don't know that for sure, however. The input could
just as easily have failed because of a format error.
break;
// not okay, parsing error
throw std::runtime_error("invalid stream content");
Or a hard IO error (disk read error, etc.).
}
The short form, using the implicit conversion of a stream to a
void* (which then can be used as boolean) is this:
while( in >> record)
handle(record);
if(!in.eof())
// not okay, parsing error before end of file
throw std::runtime_error("invalid stream content");
I was just hoping someone on this list could explain to me
why eof doesn't work the way i'm thinking it should be
working, and if there is anyplace in the standards that
describes how eof should work, when it should return true
and when it should return false.
Well, I dare say that any better documentation says that this
member function returns true when an input operation failed
(note the past tense) due to reaching EOF. It's probably just
that it doesn't do what you would expect it to do. ;)
The names of the functions aren't necessarily well chosen:
good(), for example, is not the inverse of bad() (nor of
fail()). But the real problem is that some functions, like
eof(), are present principally for the use of operator<< and
operator>>, whereas others (e.g. fail()) are designed to give
useful information to the user. In the case of EOF, there is
also the problem that the streams don't distinguish between
internal eof (which means that the >> or << operator should no
longer try to read from the streambuf), and external eof()
(which means that the last input failed because there was no
more data to be read, and cannot occur on output).
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]