Little Endian - Big Endian Problem

4
votes

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

7
c++endianness
You are using the return value, right? While you take x by reference, you never actually modify it. – James McNellis
@VirusEcks: show your complete program, there's no point a bunch of people sitting around guessing what it is you've done wrong. – Steve Jessop
So when you said, "I use the return", what did you mean? The function doesn't modify y. The value you print out is y. The output of this program surely is "822167888". If you print out r, you'll see the endian-reversed value. – Steve Jessop
@Steve: and we need to cout << hex, otherwise we get decimal output – Vlad
@VirusEcks: HELLO! YOU'RE PRINTING OUT y! Why would you think that your function, endian_swap, modifies y in any way? It doesn't. – Steve Jessop

7 Answers

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

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

1
votes

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

0
votes

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); 
}
0
votes

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

0
votes

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.

0
votes

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.