Getting the integer representation of a float

[Stein Gulbrandsen]

What is the best way to get to the integer representation of a float?

I would like to do
int& toIntByCast (float& a) {return *reinterpret_cast<int*> (&a);}
but is this legal?

Is this safer?
int toIntByUnion (const float& a) {
union {float f; int i;} u = {a};
return u.i;
}

Or are there better ways?

 

[Ron Natalie]

What is the best way to get to the integer representation of a float?

I would like to do
int& toIntByCast (float& a) {return *reinterpret_cast<int*> (&a);}
but is this legal?

Is this safer?
int toIntByUnion (const float& a) {
union {float f; int i;} u = {a};
return u.i;
}

Or are there better ways?

They both rely on the whim of the implementation but should
provide appoximately the same chance of working. The only
real guarantee is to copy the float to sizeof(float) chars and
then sizeof(int) chars back to int (hoping the two sizes are
indeed thee same).

 

[Ivan Vecerina]

: What is the best way to get to the integer representation of a float?
:
: I would like to do
: int& toIntByCast (float& a) {return *reinterpret_cast<int*> (&a);}
: but is this legal?
Formally, behavior will be undefined.

: Is this safer?
: int toIntByUnion (const float& a) {
: union {float f; int i;} u = {a};
: return u.i;
: }
This would probably even be less portable.

: Or are there better ways?

The first option displayed above is used often, and will
"work" as you expect on most platforms. The union trick
is just more complicated and not better in any way.

Formally, the correct way to access the representation
of an object (here a float) is to access it as an array
of 'unsigned char':
unsigned char* p = (unsigned char*)aFloat;
for( int i = 0 ; i<sizeof(aFloat) ; ++i )
... read p;


hth -Ivan

 

[Ron Natalie]

: What is the best way to get to the integer representation of a float?
:
: I would like to do
: int& toIntByCast (float& a) {return *reinterpret_cast<int*> (&a);}
: but is this legal?
Formally, behavior will be undefined.

Implmentation defined.

 

[Victor Bazarov]

[..]
Formally, the correct way to access the representation
of an object (here a float) is to access it as an array
of 'unsigned char':
unsigned char* p = (unsigned char*)aFloat;

unsigned char* p = (unsigned char*) & aFloat;

for( int i = 0 ; i<sizeof(aFloat) ; ++i )
... read p;

V

 

[Victor Bazarov]

Implmentation defined.

Please quote the Standard. All I see is "unspecified", which is
basically the same as "undefined".

V

 

[Ron Natalie]

Please quote the Standard. All I see is "unspecified", which is
basically the same as "undefined".

I guess you are right. The implementation defined applies to types
other than pointers.

The real answer is aliasing to chars are the only safe thing you can do.

 

[Walter Bright]

What is the best way to get to the integer representation of a float?

Since you're stepping outside of what's strictly portable anyway, you
might as well go ahead and just do:

*(int*)&a

I'd probably throw in:

assert(sizeof(int) == sizeof(float));

so you'll be alerted if the first line isn't going to work.

Walter Bright
www.digitalmars.com C, C++, D programming language compilers