Changing endianness

I'm trying to swap endianness in a big-endian file: my platform is little-endian, and so things are coming out wierd:

Code:

#include <iostream>
#include <fstream>

using namespace std;

// Endianness issue

inline void endian_swap(int& x) {

        // Int is 4 bytes on this machine

        x = (x >> 24) |
        ((x<<8) & 0x00FF0000) |
        ((x>>8) & 0x0000FF00) |
        (x<<24);
}

int main(int argc, char** argv) {


        const char * gcaf=argv[1];

        const float GCA_VERSION=5.0;
        const int GCA_NO_MRF = 1;
        const int GIBBS_NEIGHBORHOOD=6;
        const int GIBBS_NEIGHBORS=GIBBS_NEIGHBORHOOD;
        const int MAX_LABELS=20;

        int * v = new int;

        ifstream GCA;

        GCA.open(gcaf, ifstream::binary);


        GCA.read((char*)v, sizeof(float));

        endian_swap(v[0]);
        if (v[0] == GCA_VERSION) puts("hooray!");
        else puts("darn");


// gives the wrong answer!!!
        cout << v[0] << '\n';
}

The first four bytes in the file correspond to a `float', but I couldn't use the binary operators `>>' or `<<' with a float on either side, which is why the signature has an "int&". Any suggestions for reading in the file as little-endian? I tried googling, but didn't get much.

as I understand you need an reinterpreter_cast here

The int should be an unsigned int as well.

You could probably turn it into a template pretty easily so it will swap the endiness of any size of int.

Thanks. I changed the following lines

Code:

inline void endian_swap(unsigned int& x) {
// ...
unsigned int * v = new unsigned int[1];
//...
GCA.read(reinterpret_cast<char*>(v), sizeof(unsigned int));
//...
cout << static_cast<float>(v[0]) << '\n'; // The first four bytes of the file correspond to 
                                                                // a float

but still got a spurious value for v[0]:

Code:

% ./program <file>
1.08423e+09

The output should be 5.0 (this is what I get on a big-endian system, anyway). What's going wrong?

>> static_cast<float>(v[0])

You're casting an int to float. You need to cast the int* to a float* and then dereference.

>> inline void endian_swap(int& x) {

Be careful, though, as sizeof( int ) may not be 4.

>> You could probably turn it into a template pretty easily so it will swap the endiness of any size of int.

This should work with any POD:

Code:

inline bool little_endian( void )
{
    typedef unsigned char* pbyte;
    static unsigned long word = 0x1;
    static bool is_little_endian_machine = ( *pbyte( &word ) == 0x1 );
    return is_little_endian_machine;    
}

inline bool big_endian( void )
{
    return !little_endian( );
}

namespace detail {

template < typename Type >
Type& endian_conversion_dispatcher_( Type* value, bool little_endian_mode )
{
    typedef unsigned char* pbyte;
    if( little_endian( ) != little_endian_mode )
        std::reverse( pbyte( value ), pbyte( value ) + sizeof( Type ) );
    return *value;    
}

template < typename Type >
inline Type endian_conversion_dispatcher_( Type const& value, bool little_endian_mode )
{
    Type result = value;
    return endian_conversion_dispatcher_( &result, little_endian_mode );    
}

} // namespace detail

template < typename Type >
inline Type& little_endian( Type* value )
{
    return detail::endian_conversion_dispatcher_( value, true );    
}

template < typename Type >
inline Type little_endian( Type const& value )
{
    return detail::endian_conversion_dispatcher_( value, true );    
}

template < typename Type >
inline Type& big_endian( Type* value )
{
    return detail::endian_conversion_dispatcher_( value, false );    
}

template < typename Type >
inline Type big_endian( Type const& value )
{
    return detail::endian_conversion_dispatcher_( value, false );    
}

Another benefit here is that the template automatically detects the endianess of the machine it's running on, so that you don't have to change the user side of the code. So for instance, let's say you have a float value you want to store in a file in big-endian format. Right before the value is written to the file, it is passed through the big_endian function. Likewise, when the value is later read from a file, the big_endian function is used to convert it back. (Note that the functions that take no arguments are only for implementing certain optimizations, and needn't be used as logic during conversion.)

I thought floating point numbers can't easily be sent over the network the way integers can?
Endianness - Wikipedia, the free encyclopedia
Is there any point in changing the endianess of floating point numbers?

I thought floating point numbers can't easily be sent over the network the way integers can?

You can, as long as you're not ignorant of what you're sending... if it were me, IEEE-754, big endian. No different from other types of serialization. (Granted, it might not have a standard attached to it...)
If you know that a certain floating point number has a certain range, say [0, 1), I've seen people send an integer, like, where 0 = 0.0, and 0xFFFF = 65535/65536.0. (Using more or less bytes depending on how accurate you need.)

Maybe not. I guess they would have to be serialized in some other way.

I think I heard someone here say that if you don't know what floating point format each end is using, floating point numbers should be converted to strings before being sent over the network, then changed back to floats on the other end.