Little Endian - Big Endian Problem

Question

Little Endian vs Big Endian

Big Endian = 0x31014950
Little Endian = 0x50490131

However Using this Method

inline unsigned int endian_swap(unsigned int& x)  
{
return ( ( (x & 0x000000FF) << 24 ) | 
         ( (x & 0x0000FF00) << 8  ) |
         ( (x & 0x00FF0000) >> 8  ) |
         ( (x & 0xFF000000) >> 24 ) );
}

result = 0x54110131
i spent lot of time trying lots of similar methods and even a library one like

unsigned long _byteswap_ulong(unsigned long value);  

But Still no luck .. all returns same result

EDIT
I'm Working on Little-Endian System with Microsoft Visual Studio 2008
the example as Follows

int main()
{
    unsigned int y = 0x31014950;
    unsigned int r = endian_swap( y );
    std::cout << r;
}  

the example posted on Ideone.com is correct .. but it doesn't work with me

EDIT

std::cout << std::hex << r;  

Either Ways Pals .. Hex or Not it's not getting the Right Number .. Either Visual Studio got a serious Error in it's Debugger or My Whole Machine ..
Because i Replaced the Whole Code with a More Slow Redunant code but still getting same results
BTW if it makes any difference .. i'm using Debugger to Break after the function to check the result

Answer 1

• Are you printing the result correctly?
• Does the fact that you're passing in a reference instead of a value make a difference?

Answer 2

Your code seems to be correct.

The following program (http://ideone.com/a5TBF):

#include <cstdio>

inline unsigned int endian_swap(unsigned const int& x)  
{
return ( ( (x & 0x000000FF) << 24 ) | 
         ( (x & 0x0000FF00) << 8  ) |
         ( (x & 0x00FF0000) >> 8  ) |
         ( (x & 0xFF000000) >> 24 ) );
}

int main()
{
    unsigned int x = 0x12345678;
    unsigned int y = endian_swap(x);
    printf("%x %x\n", x, y);
    return 0;
}

outputs:

12345678 78563412

---

Edit:
you need std::cout << std::hex << r, otherwise you are printing (1) wrong variable, and (2) in decimal :-)

See this example: http://ideone.com/EPFz8

Answer 3

Eliminate the ampersand in front of the x in your argument specifier. You want to pass the value.

Answer 4

Have you unit-tested your code?

On my platform, this passes:

void LittleEndianTest::testLittleEndian()
{
    unsigned int x = 0x31014950;
    unsigned int result = 
         (
             ( (x & 0x000000FF) << 24 ) + 
             ( (x & 0x0000FF00) << 8  ) +
             ( (x & 0x00FF0000) >> 8  ) +
             ( (x & 0xFF000000) >> 24 ) 
         );

    CPPUNIT_ASSERT_EQUAL((unsigned int)0x50490131, result); 
}

Answer 5

The example in your edit is outputting y not r. The input y is, of course, not modified.

Answer 6

If I run the code you posted, it gives the correct result: endian_swap ( 0x31014950 ) == 0x50490131.

To get the result: endian_swap ( 0x31014950 ) == 0x54110131, your code must be equivalent to this:

#define __
inline unsigned int endian_swap(unsigned int& x)  
{                  //0x31014950  ->            0x54110131
    return  ( ( (x & 0x000000FF) << 24 ) |   //  50
        __    ( (x & 0x00F0F000) << 12 ) |   //   4
        __    ( (x & 0x00FF0000) << 4  ) |   //    1  
        __    ( (x & 0x00FF0000) << 0  ) |   //     1  
        __    ( (x & 0x00FF0000) >> 8  ) |   //      01
        __    ( (x & 0xFF000000) >> 24 ) );  //        31        
}

Check you haven't got similar differences in your code too.

Answer 7

Bit operators are not useful because they operates as if the bits are arranged in order from least significant bit to most significant bit regardless of the true internal byte order.

void isBigEndian()
{
    void *number;
    number = (int *) new int(0x01000010);
    // 0x01000010
    //   01 00 00 10                                      Hexadecimal
    //   0    1      0    0      0    0       1    0
    //   0000 0001   0000 0000   0000 0000    0001 0000   Bit
    //   1           0           0            16          Decimal
    char *byte;
    byte = (char *)number;
    cout << static_cast<int>(*byte);//prints 16: Little Endian
}

You change the number above and make it return 1 when it is BigEndian.