Question

I’m sure this is a very common operation when doing any kind of network programming (or I/O with files) but I can’t find the answer.

Basically I have a datagram packet coming in down the network which has a series of single precision floating point numbers (4 bytes each).

I have written some basic networking code which reads from a socket and stores the data into a buffer which is declared as follows:

char buffer[24];

This is my deserialization code:

for (int i=0; i<6; i++) {
    float *pf = reinterpret_cast<float*>(buffer + i*sizeof(float));
    printf("%f\n", *pf);
}

but it causes my program to crash.

If someone could point me to a good tutorial on this type of thing i.e. managing, storing and interpreting data, I’d really appreciate it! I’ve looked but I don’t know what to search for.

Answer 1

If they are really sending floats — which I wouldn’t recommend, if you have a choice — then you have to do some bit hackery.

Here is a utility library I wrote to do just this kind of thing. It works on Windows (MSVC) and Linux (GCC). It might not work on other platforms! Use at your own risk.

/**************  UTILITY ******************************/
template<class Val> Val ntohx(const Val& in)
{
    char out[sizeof(in)] = {0};
    for( size_t i = 0; i < sizeof(Val); ++i )
        out[i] = ((char*)&in)[sizeof(Val)-i-1];
    return *(reinterpret_cast<Val*>(out));
}

template<> uint16_t ntohx<uint16_t>(const uint16_t & v)
{
    return ntohs(v);
}

template<> uint32_t ntohx<uint32_t>(const uint32_t & v)
{
    return ntohl(v);
}

template<> uint64_t ntohx<uint64_t>(const uint64_t & v)
{
    uint32_t ret [] =
    {
        ntohl(((const uint32_t*)&v)[1]),
        ntohl(((const uint32_t*)&v)[0])
    };
    return *((uint64_t*)&ret[0]);
}
template<> float ntohx<float>(const float& v)
{
    uint32_t const* cast = reinterpret_cast<uint32_t const*>(&v);
    uint32_t ret = ntohx(*cast);
    return *(reinterpret_cast<float*>(&ret));
}

template<class Val> bool ieee_isnan(const Val& val)
{
    // According to the IEEE Standard for floating-point numbers, 
    // NaNs have the interesting attribute of always returning
    // false in comparisons; even to themselves.
    // All platforms we currently support use IEEE floating points,
    // so this should work. [Dib]
    return val != val;
};