Re: Reading and Writing float value of infinity to file.
"James Kanze" <james.kanze@gmail.com> wrote in message
news:1192872819.439304.147720@q3g2000prf.googlegroups.com...
On Oct 19, 2:26 pm, "Jim Langston" <tazmas...@rocketmail.com> wrote:
"Jim Langston" <tazmas...@rocketmail.com> wrote in message
news:Gc1Si.76$dr4.63@newsfe02.lga...> "James Kanze"
<james.ka...@gmail.com> wrote in message
news:1192788360.167539.75570@i13g2000prf.googlegroups.com...
On Oct 19, 8:56 am, "Jim Langston" <tazmas...@rocketmail.com> wrote:
The output of the following program is:
1.#INF
1
But:
1.#INF
1.#INF
was expected and desired. How can I read a value of infinity
from a stream?
[Snip discussion about C++ not supporing infinity]
Well, this is what I came up with. Output is as I want. Do
you see anything I'm doing wrong here? Of course I'll have to
come up with a better name than "MyFloat".
1.#INF
1 2.2 3.3
1.#INF 2.2 3.3
#include <iostream>
#include <fstream>
#include <limits>
#include <string>
class MyFloat
{
public:
MyFloat( float Value = 0.0f ): Value( Value ) {}
operator float() { return Value; }
float Value;
};
std::istream& operator>>( std::istream& is, MyFloat& mf )
{
if ( is >> mf.Value )
{
if ( mf.Value == 1.0f && is.peek() == '#' )
{
std::string Rest;
is >> Rest;
if ( Rest == "#INF" )
mf.Value = std::numeric_limits<float>::infinity();
}
}
return is;
}
I'm not sure I like that. You've built in knowledge of how your
implementation formats infinity, and I'll bet that this format
is not guaranteed. I'd do something more along the lines of:
std::istream&
operator>>( std::istream& in, MyFloat& out )
{
std::string s ;
in >> s ;
One thing here, though, is you read a string from istream. This could put
is in a different state then if this operator>> wasn't used. For example.
Say what is waiting is:
123.45And that's all.
Using a pure is >> float
"And that's all" would be waiting in the stream. With this function this
way, however, "And that's all" will be thrown away.
The way I did it it would only be thrown away if the first character was #,
not as likely an occurance (but adminttedly still could happen).
Other than that, I agree with your assessment. But I don't like putting the
stream in a state that would be different if my function wasn't used.
if ( in ) {
static std::string const
infRepresentation =
initInfRepresentation() ;
if ( s == infRepresentation ) {
out.value = std::numeric_limits< float >::infinity() ;
} else {
std::istringstream t( s ) ;
t >> out.value ;
}
}
return in ;
}
with:
std::string
initInfRepresentation()
{
std::ostringstream t ;
t << std::numeric_limits< float >::infinity() ;
return t.string() ;
}
Actually, I'd go even further, since I'd want to handle at
least positive and negative infinity, and I'd probably make the
comparison case insensitive. But you get the idea.
And of course, regardless of the solution, you have to be aware
that it will break anytime the compiler changes its
representation of infinity. Which in your case seems almost
inevitable, given that the C99 standard requires "[+-]inf" or
"[+-]infinity", and that this requirement will almost certainly
be part of the next version of the C++ standard. So if you want
any kind of portability, you really have to use your MyFloat for
both output and input.