Converting from double to hexadecimal back to double using union

Question

I am not even sure if my title is accurate, but for my project, I need to take a double and convert it into a hexadecimal and then convert it back to a double. But in order to do that, I think I would need to overload the operator << before I can output the answer. This is what I have so far, but I get prompted that "no operator "<<" match these operands"> Could someone please point me in the right direction of how I should overload the << operator in main? Thank you!

#include <iostream>
#include <iomanip>
#include <cstdint>

using namespace std;

void out_char_as_hex(int c)
{
    cout << hex << setw(2) << setfill('0') << c;
}


int main()
{
    union { double d; uint64_t u; } tmp;
    double x = -0.15625;
    tmp.d = x;

    cout << out_char_as_hex(tmp.d) << endl;

    return 0;
}

if it helps this is the question "If x is a variable of type double, it binary representation can be re-interpreted as a 64 bits integer, which can be represented exactly. To do that, you can either get the memory address to the variable of type double and reinterpret cast it to a 64-bit int pointer or use a union. To make the textual representation more compact, we use base 16 (hexadecimal). For example, the double number -0.15625 should be saved to file as the sequence of 16 characters bfc4000000000000 (see example in DemoHex.cpp, which use a union). When reading, you need to read the integer number saved in hexadecimal format and re-interpret it as a double. You need to modify the implementation of the operator<< for double and implement the overload of the operator>>"

Answer 1

This is a version that doesn't use a union, but instead copies the bit pattern from a double to a uint64_t.

Assuming that this bit pattern is valid for an integer, the copying should be valid too. And it also produces the expected output.

#include <iostream>
#include <iomanip>
#include <cstdint>

using namespace std;

void out_char_as_hex(std::uint64_t c)
{
    cout << hex << setw(16) << setfill('0') << c << endl;
}


int main()
{
    uint64_t u;
    double x = -0.15625;

    std::memcpy(&u, &x, sizeof(u));

    out_char_as_hex(u);

    return 0;
}

However, this isn't the solution the professor has requested, so probably "wrong".

Answer 2

If conversion is just for printing then you don't need to overload any operator. Using io manipulator 'std::hexfloat' you can print float in hexdecimal.

Based on you example code and explanation, I think you are trying to do something as follows

#include <iostream>
#include <iomanip>

union test
{
    double x;
    uint64_t y;
};

// Insertion operator is overloaded to take union and 
// print uint64_t value from it.  
std::ostream & operator << (std::ostream &out, const test &t)
{
    out << std::hex << std::setw(50) << std::setfill('0') << t.y;
    return out;
}

int main()
{
    test t;
    t.x = -0.15625;
    std::cout << t << std::endl;    
    return 0;
}

Whatever is printed here is a bit pattern that is used to store float number in memory (sign bit, exponent and mantissa).

UPDATE: Above code will result into undefined behavior as we are NOT reading from most recently written member(Reference: http://en.cppreference.com/w/cpp/language/union)

Here is an alternate way of doing it without using union.

#include <iostream>
#include <iomanip>

struct test
{
    double x;
};

std::ostream & operator << (std::ostream &out, test &t)
{
    uint64_t *y = reinterpret_cast<uint64_t *>(&t.x);
    out << std::hex << std::setw(50) << std::setfill('0') << *y;
    return out;
}

int main()
{
    test t;
    t.x = -0.15625;
    std::cout << t << std::endl;
    return 0;
}