~traits::eof()?

[Mark A. Gibbs]

Good day,

What is the safest way to get a non-end of file value?
char_traits<cha r_type>::eof() will get me eof, but how can I safely and
consistently generate a value that is not eof? should i use
~char_traits<ch ar_type>::eof() ? char_traits<cha r_type>::int_ty pe()?
char_traits<cha r_type>::eof() + 1?
while(!char_tra its<char_type>: :not_eof(char_t raits<char_type >::int_type(ran d())))?

mark

[Howard]

"Mark A. Gibbs" <x_*********@ro gers.com_x> wrote in message
news:vR******** **@news04.bloor .is.net.cable.r ogers.com...

Good day,

What is the safest way to get a non-end of file value?
char_traits<cha r_type>::eof() will get me eof, but how can I safely and
consistently generate a value that is not eof? should i use
~char_traits<ch ar_type>::eof() ? char_traits<cha r_type>::int_ty pe()?
char_traits<cha r_type>::eof() + 1?
while(!char_tra its<char_type>: :not_eof(char_t raits<char_type >::int_type(ran d
())))?
mark

I think you are confused about eof(). It is a function, not a value.

Calling eof() on a stream checks if the stream has reached the end by a
previous read from the stream. When reading from a stream, you read until
reading fails. Then you can check if the failure was due to reaching the
end (as expected) or due to some kind of unexpected failure (an error). You
don't check the input and test it for being an "eof value", nor a "non-eof
value", because there is no such value in the first place.

Also, in C++, the ~ symbol is not used as a "not" operator. That symbol is
used to denote a destructor. The ! symbol is logical not. But as I stated
before, it has nothing to do with eof(), which is a function, not a value.

-Howard

[P.J. Plauger]

"Howard" <al*****@hotmai l.com> wrote in message
news:Pc******** *************@b gtnsc04-news.ops.worldn et.att.net...

"Mark A. Gibbs" <x_*********@ro gers.com_x> wrote in message
news:vR******** **@news04.bloor .is.net.cable.r ogers.com...

Good day,

What is the safest way to get a non-end of file value?
char_traits<cha r_type>::eof() will get me eof, but how can I safely and
consistently generate a value that is not eof? should i use
~char_traits<ch ar_type>::eof() ? char_traits<cha r_type>::int_ty pe()?
char_traits<cha r_type>::eof() + 1?

while(!char_tra its<char_type>: :not_eof(char_t raits<char_type >::int_type(ran d ())))?

mark

I think you are confused about eof(). It is a function, not a value.

Calling eof() on a stream checks if the stream has reached the end by a
previous read from the stream. When reading from a stream, you read until
reading fails. Then you can check if the failure was due to reaching the
end (as expected) or due to some kind of unexpected failure (an error).

You don't check the input and test it for being an "eof value", nor a "non-eof
value", because there is no such value in the first place.
I think you are confused about char_traits<cha r_type>::eof(). It
doesn't check for end-of-file, as does the feof function declared
in <stdio.h>. Rather, it returns the end-of-file code suitable
for a stream of char_type elements. You *do* check the input you
obtain from a stream buffer and test it for being an "eof value".
Also, in C++, the ~ symbol is not used as a "not" operator. That symbol is used to denote a destructor. The ! symbol is logical not. But as I stated before, it has nothing to do with eof(), which is a function, not a value.

Also, in C++ the ~ symbol is *also* used as a "not" operator. That
symbol is used to denote a bitwise inversion. When applied to the
value returned by eof(), it very likely will change it to a value
that does not compare equal to eof().

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com

[Howard]

"P.J. Plauger" <pj*@dinkumware .com> wrote in message
news:8D******** *********@nwrdd c02.gnilink.net ...

"Howard" <al*****@hotmai l.com> wrote in message
news:Pc******** *************@b gtnsc04-news.ops.worldn et.att.net...

"Mark A. Gibbs" <x_*********@ro gers.com_x> wrote in message
news:vR******** **@news04.bloor .is.net.cable.r ogers.com...

Good day,

What is the safest way to get a non-end of file value?
char_traits<cha r_type>::eof() will get me eof, but how can I safely and consistently generate a value that is not eof? should i use
~char_traits<ch ar_type>::eof() ? char_traits<cha r_type>::int_ty pe()?
char_traits<cha r_type>::eof() + 1?

while(!char_tra its<char_type>: :not_eof(char_t raits<char_type >::int_type(ran d

())))?

mark

I think you are confused about eof(). It is a function, not a value.

Calling eof() on a stream checks if the stream has reached the end by a
previous read from the stream. When reading from a stream, you read until reading fails. Then you can check if the failure was due to reaching the end (as expected) or due to some kind of unexpected failure (an error).

You

don't check the input and test it for being an "eof value", nor a "non-eof value", because there is no such value in the first place.

I think you are confused about char_traits<cha r_type>::eof(). It
doesn't check for end-of-file, as does the feof function declared
in <stdio.h>. Rather, it returns the end-of-file code suitable
for a stream of char_type elements. You *do* check the input you
obtain from a stream buffer and test it for being an "eof value".

Interesting. I take it then that there are streams that you read where
you do check the value returned instead of using std::eof()? What kind of
streams would those be? Certainly not an actual file, right? I have to
admit I've never used a stream other than for normal file reading, or a
string stream for simple character conversions.

Also, in C++, the ~ symbol is not used as a "not" operator. That symbol

is

used to denote a destructor. The ! symbol is logical not. But as I

stated

before, it has nothing to do with eof(), which is a function, not a

value.
Also, in C++ the ~ symbol is *also* used as a "not" operator. That
symbol is used to denote a bitwise inversion. When applied to the
value returned by eof(), it very likely will change it to a value
that does not compare equal to eof().

True. But in that case, any non-identity operation at all would suffice, if
all you wanted was a value different from whatever was returned. And as you
pointed out to the OP, the correct symbol is !, if you want to know when
something is "not true", in this case when a value is "not" the eof() value.

-Howard

[Mark A. Gibbs]

P.J. Plauger wrote:

Also, in C++ the ~ symbol is *also* used as a "not" operator. That
symbol is used to denote a bitwise inversion. When applied to the
value returned by eof(), it very likely will change it to a value
that does not compare equal to eof().

that was pretty much my thought. same for "eof() + 1" or something of
the like. but is there no simple way to generate a value of type
char_traits<cha r_type>::int_ty pe that is guaranteed to satisfy
char_traits<cha r_type>::not_eo f()?

(and if there isn't, mr. plauger, maybe you could stick one in your
library. you know where to find me for the royalties ^_-)

incidently, where i noticed the issue is in basic_streambuf ::overflow()
(and the like). it would be nice to do:

int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? c : traits::eof();
}

but c could be eof() and the call could be successful, in which case
this code would generate spurious errors. the only thing i could think
of was:

int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? traits::not_eof (c) : traits::eof();
}

would that be guaranteed to work as expected?

mark

[Dietmar Kuehl]

Mark A. Gibbs wrote:

but is there no simple way to generate a value of type
char_traits<cha r_type>::int_ty pe that is guaranteed to satisfy
char_traits<cha r_type>::not_eo f()?
'not_eof()' is probably actually the function you are looking for: it
return a value different to 'eof()' even if you pass it 'eof()'. That,
you apparently want

traits::not_eof (traits::eof()) ;
(and if there isn't, mr. plauger, maybe you could stick one in your
library. you know where to find me for the royalties ^_-)
It is already there but you are, of course, free to sent royalties
wherever you want to...
int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? c : traits::eof();
}

but c could be eof() and the call could be successful, in which case
this code would generate spurious errors.
That is what 'not_eof()' is for:

return success? traits::not_eof (c): traits::eof();

The 'not_eof()' function has the property to return 'c' unless 'c' is
actually 'eof()' in which case 'not_eof()' returns some value != 'eof()'.
the only thing i could think
of was:

int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? traits::not_eof (c) : traits::eof();
}

would that be guaranteed to work as expected?

Well, yes, that is how it is designed...
--
<mailto:di***** ******@yahoo.co m> <http://www.dietmar-kuehl.de/>
<http://www.contendix.c om> - Software Development & Consulting

[Mark A. Gibbs]

Dietmar Kuehl wrote:

'not_eof()' is probably actually the function you are looking for: it
return a value different to 'eof()' even if you pass it 'eof()'. That,
you apparently want

traits::not_eof (traits::eof()) ;

ah, so traits::eof() can never be 0. perfect. thank you.

(and if there isn't, mr. plauger, maybe you could stick one in your
library. you know where to find me for the royalties ^_-)

It is already there but you are, of course, free to sent royalties
wherever you want to...

*sigh*

mark

[P.J. Plauger]

"Howard" <al*****@hotmai l.com> wrote in message
news:_V******** *************@b gtnsc04-news.ops.worldn et.att.net...

I think you are confused about eof(). It is a function, not a value.

Calling eof() on a stream checks if the stream has reached the end by a previous read from the stream. When reading from a stream, you read until reading fails. Then you can check if the failure was due to reaching the end (as expected) or due to some kind of unexpected failure (an error).

You

don't check the input and test it for being an "eof value", nor a "non-eof value", because there is no such value in the first place.
I think you are confused about char_traits<cha r_type>::eof(). It
doesn't check for end-of-file, as does the feof function declared
in <stdio.h>. Rather, it returns the end-of-file code suitable
for a stream of char_type elements. You *do* check the input you
obtain from a stream buffer and test it for being an "eof value".

Interesting. I take it then that there are streams that you read where
you do check the value returned instead of using std::eof()?

Please pay attention. THERE IS NO std::eof()!
What kind of
streams would those be? Certainly not an actual file, right? I have to
admit I've never used a stream other than for normal file reading, or a
string stream for simple character conversions.
Evidently. The function eof() IN TEMPLATE CLASS char_traits is used
by the iostreams code to detect when a stream buffer has encountered
end of stream. That certsainly includes actual files. You've probably
never had to use this member function eof() because it's part of the
under-the-hood implementation of iostreams.
Also, in C++, the ~ symbol is not used as a "not" operator. That

symbol is

used to denote a destructor. The ! symbol is logical not. But as I

stated

before, it has nothing to do with eof(), which is a function, not a

value.

Also, in C++ the ~ symbol is *also* used as a "not" operator. That
symbol is used to denote a bitwise inversion. When applied to the
value returned by eof(), it very likely will change it to a value
that does not compare equal to eof().

True. But in that case, any non-identity operation at all would suffice,

if all you wanted was a value different from whatever was returned.
Yes. I was merely correcting your misinformation about ~.
And as you
pointed out to the OP, the correct symbol is !, if you want to know when
something is "not true", in this case when a value is "not" the eof()

value.

You're confusing me with someone else.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com

[P.J. Plauger]

"Mark A. Gibbs" <x_*********@ro gers.com_x> wrote in message
news:X%******** ******@news04.b loor.is.net.cab le.rogers.com.. .

P.J. Plauger wrote:

Also, in C++ the ~ symbol is *also* used as a "not" operator. That
symbol is used to denote a bitwise inversion. When applied to the
value returned by eof(), it very likely will change it to a value
that does not compare equal to eof().
that was pretty much my thought. same for "eof() + 1" or something of
the like. but is there no simple way to generate a value of type
char_traits<cha r_type>::int_ty pe that is guaranteed to satisfy
char_traits<cha r_type>::not_eo f()?

Only if you have a candidate "character" in hand that you assuredly
want *not* turned into an eof. That's what not_eof is for.
(and if there isn't, mr. plauger, maybe you could stick one in your
library. you know where to find me for the royalties ^_-)
That's a helluva way to earn royalties, adding a nonstandard patch
to a kludge to an inelegant design.
incidently, where i noticed the issue is in basic_streambuf ::overflow()
(and the like). it would be nice to do:

int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? c : traits::eof();
}

but c could be eof() and the call could be successful, in which case
this code would generate spurious errors. the only thing i could think
of was:

int_type overflow(int_ty pe c = traits::eof())
{
// whatever
return (success) ? traits::not_eof (c) : traits::eof();
}

would that be guaranteed to work as expected?

Once you permit a valid character code to pun with eof(), it's hard
to say what "work" means anymore.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com

[P.J. Plauger]

"Mark A. Gibbs" <x_*********@ro gers.com_x> wrote in message
news:40******** ******@rogers.c om_x...

Dietmar Kuehl wrote:

'not_eof()' is probably actually the function you are looking for: it
return a value different to 'eof()' even if you pass it 'eof()'. That,
you apparently want

traits::not_eof (traits::eof()) ;

ah, so traits::eof() can never be 0. perfect. thank you.

How did you deduce that? It's almost certainly true, but I doubt
that it's guaranteed.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com