Thread: Double's and floats, i need their bytes.

I have adapted the above code in to this:

Code:

bool isOSBigEndian()
{
	short check = 0xAABB;
	
	uint8_t* endianCheck = reinterpret_cast<uint8_t*>(&check);
	return (endianCheck[0] == 0xAA && endianCheck[1] == 0xBB);
}

uint8_t* convertDoubleToBytes(double value)
{
	uint8_t* bytes = reinterpret_cast<uint8_t*>(&value);
	if (isOSBigEndian())
	{
		uint8_t* swappedBytes = new uint8_t[sizeof(double)];
		for (int i = 0, j = 7; i <= 7 && j >= 0; i++, j--)
		{
			swappedBytes[i] = bytes[j];
		}
		return swappedBytes;
	}
	else
	{
		return bytes;
	}
}

The check for endiannes works on both platforms. I get false on X86 and true on PPC.

But the bytes i get from the convertDoubleToBytes function are like garbage when compared to those from an union. The numbers don't change between different executions of the program.

From function:

Code:

154, 159, 4, 8, 95, 140, 4, 8

From union:

Code:

154, 153, 153, 153, 153, 25, 73, 64

The test was done on a X86 machine.

I thought maybe the function was correct in some sort of odd way, so i tried to convert it back to a double using the following:

Code:

double* value = reinterpret_cast<double*>(bytes);

and (probably very wrong)

Code:

double* value = (double*)((void*)bytes);

Both returned this value:

Code:

4.86187e-270

I can't think of any solution, and neither what the problem could be.

After some fiddling around with the new swapping code you graciously came up with, i noticed something odd. When i changed the value of the double i was converting to bytes, i saw that only one value of the bytes changed, and the rest stayed the same.

So i thought it might not be the function converting the double in to bytes that is at fault, but maybe the code printing the byte array was at fault.

So i glanced over the code that printed out the bytes, and i could not find anything. To quickly overcome any headaches searching for the fault in this piece code that was never going to be used again (it was temporary code), i conjured up this:

Code:

    bool same = true;
    for (int i = 0; i < sizeof(double); i++)
    {
	if (bytes[i] != d_u.data[i])
	{
	    same = false;
	    break;
	}
    }
    std::cout << (same ? "Same" : "Not the same") << "\n";

This piece code checked if the byte arrays of the conversion, and that of an union, was the same (i was using a X86 machine). And they were. So it must be the code that printed out the byte array that is at fault.

I will 'try' to fix the bug in the code printing the byte array myself, since its unrelated to this topic. But if i can't, i will be certain to flee back to here .

Here is the piece of code that eventually did the job:

Code:

bool isOSBigEndian()
{
	short check = 0xAABB;
	
	uint8_t* endianCheck = reinterpret_cast<uint8_t*>(&check);
	return (endianCheck[0] == 0xAA && endianCheck[1] == 0xBB);
}

template<typename T> void ByteSwap(T& Data)
{
	T Temp = Data;
	uint8_t* pData = reinterpret_cast<uint8_t*>(&Data);
	uint8_t* pTemp = reinterpret_cast<uint8_t*>(&Temp);
	for (int i = 0; i < sizeof(Data); i++)
		pData[i] = pTemp[(sizeof(Data) - 1) - i];
}

uint8_t* convertDoubleToBytes(double value)
{
	if (isOSBigEndian())
	{
		ByteSwap<double>(value);
		uint8_t* bytes = reinterpret_cast<uint8_t*>(&value);
		return bytes;
	}
	else
	{
		uint8_t* bytes = reinterpret_cast<uint8_t*>(&value);
		return bytes;
	}
}

Thanks for all your help