binary representation of double, conversion of double to unsigned char and int

[krishna81m]

I am a newbie and have been trying to understand conversion from double to int and then back to int using the following code was posted on the c++ google group. Could someone help me out with understanding why and how a double can be represented in bits and bytes and which of the following can allow us to view the binary representation, unsigned char representation and then convert back to int please...

#include<iostream>
#include<iomanip>
#include <bitset>
#include <limits> 
using namespace std;
 
union
{
    double d;
    char c[sizeof(double)];
} conv;
 
int main()
{
    // int to float can be done has *(reinterpret_cast<float *>(&intValue));
    int i = 3;
    float f = 4.34;
    f = *(reinterpret_cast<float *>(&i));
    cout << f << endl;
    cout << static_cast<int>(f) << endl;
 
    // TO STORE VALUES
    //I. double (8 bytes) conversion to a float (4 bytes)
    double n = 3221.12332;        
    long n2 = *(reinterpret_cast<long*>(&n));
    long n3 = *(reinterpret_cast<long*>(&n) + 1); 
 
    // DOES NOT WORK
    //II. using unions to get the bit representation of a double 
    conv.d = 32;
    // print out double in hex
    for (int i =0; i < sizeof(double); ++i)
        cout << hex << setfill('0') << setw(2) << conv.c[i]; 
    cout << endl;
 
    // DOES NOT WORK 
    //III. any object can be considered as a sequence of unsigned chars
    double d = 999;
    unsigned char *p=reinterpret_cast<unsigned char *>(&d);
    for(unsigned i=0; i<sizeof(d); ++i)
       cout<<static_cast<unsigned>(p[i])<<" ";
    cout<<endl;
 
    //IV. DONT KNOW IF IT WORKS
    double d1 = 1000;
    unsigned char *p1=reinterpret_cast<unsigned char *>(&d1);
    // There are systems where 1 byte is more than 8 bits
    bitset<numeric_limits<unsigned char>::digits> byte;
    for(unsigned i=0; i<sizeof(d1); ++i)
    {
        byte = p1[i];
        for(unsigned j=0; j<byte.size(); ++j)
             cout << byte[j];
    }
 
    // how do we convert to an int and see the same value as that of double
    unsigned long long int x;
    x = *(reinterpret_cast<int *>(&d1));
    cout << "int x: " << x << endl;
 
    cout<<endl;
 
    system("pause");
    return 0;       
}

[weaknessforcats]

First: Do not cast in C++. It's a bad habit.

Second: Read up on Aritmetic Conversions. An int can be converted to a double with .0 for a decimal. But the double can never be converted back to an int without truncating the decimal and losing data. Your compiler will bark at you about this.

The general rule is: Do not mix integer and floating point. Stick with one or the other.

Floating point is slow, has automatic rounding and limited accuracy and is intended for scientific use only where extreme accuracy is not required. If you have to use floating point, use double thoughout unless you can write a real reason down on paper as to why this won't work.

In the integer family, any integer (and char is an integer- there are no characters in C or C++) can be freely copied to any other integer with you being responsible that you don't lose data.

This code:

float f = 4.34;

has a bug in it. 4.34 is a double. f is a float. A float is smaller than a double so you get warnings here about truncation an possible loss of data. The correct code is:

 double f = 4.34;
 

because you aren't supposed to use float. If you insist, then at least tell the compiler to create the constant as a float:

  float f = 4.34F;   /or 4.34f
 

This is utter garbage:

f = *(reinterpret_cast<float *>(&i));

&i is the address of an int. Forcing the compiler to accept as the address of a float is just illogical. Then, after that you assign the bits in the int to the float when the arrangement of he bits in the int do not conform to IEEE754.

f is now corrupted.

Nothing after this can be analyzed.