嵌入式linux下关于大小尾端数据间的相互转换

提到体系结构时，经常遇到大小尾端的概念，这里做个总结。

       big endian：大尾端，也称大端（高位）优先存储。

       little endian：小尾端，也称小端（低位）优先存储。

     如下00000000 00000000 00000000 00000001的存储

             

       大尾端：  00000000 00000000 00000000 00000001

                     addr+0       addr+1         addr+2     addr+3         //先存高有效位（在低地址）

   

     小尾端：  00000001 00000000 00000000 00000000

                     addr+0       addr+1         addr+2     addr+3         //先存低有效位（在低地址）

     故要判断机器的体系结构是大尾端还是小尾端，以下程序可以完成任务：

   

     

一：判断大小端的2种方法

#include <stdio.h>

int is_little_endian(void)
{
  unsigned short flag = 0x1234;
  
  if(*(unsigned char *)&flag == 0x34)
    return 1;
  else
    return 0;  
}

int main(int argc, char* argv[])
{
 union endian_un
{
 short var;
 char bits[sizeof(short)];
};

 union endian_un flag;
 flag.var = 0x0102;

 if(sizeof(short) == 2)
  {
   if(flag.bits[0] == 1 && flag.bits[1] == 2)
     printf("Judged by the first method,big_endian\n");
   else if(flag.bits[0] == 2 && flag.bits[1] == 1)
     printf("Judged by the first method,little_endian\n");
   else
     printf("Cann't judged the digtal\n");
  }
  
  if(is_little_endian())
    printf("Juged by the second method ,little_endian\n");
   else
    printf("Juged by the second method,big_endian\n");

 return 0;
}

二：转换大小端

#include <stdio.h>
#include <stdio.h>

typedef unsigned int u32;
typedef unsigned short u16;

#if 0
//simple: not check varible types

#define BSWAP_16(x) \
          ( (((x) & 0x00ff) << 8 ) | \
     (((x) & 0xff00) >> 8 ) \
     )

//complex:check varible types

#else 
#define BSWAP_16(x) \
     (u16) ( ((((u16)(x)) & 0x00ff) << 8 ) | \
                 ((((u16)(x)) & 0xff00) >> 8 ) \
          )


#endif
#define BSWAP_32(x) \
     (u32) ( (( ((u32)(x)) & 0xff000000 ) >> 24) | \
                    (( ((u32)(x)) & 0x00ff0000 ) >> 8 ) | \
     (( ((u32)(x)) & 0x0000ff00 ) << 8 ) | \
     (( ((u32)(x)) & 0x000000ff ) << 24) \
              )

u16 bswap16(u16 x)
{
    return (x & 0x00ff) << 8 |
     (x & 0xff00) >> 8 
    ;
}

u32 bswap32(u32 x)
{
    return     ( x & 0xff000000 ) >>24 | 
        ( x & 0x00ff0000 ) >>8 | 
        ( x & 0x0000ff00 ) <<8 | 
        ( x & 0x000000ff ) << 24 
    ; 
}
    

int main(void)
{
    //u16 var_short = 0x123490;

    //u32 var_int = 0x1234567890;

    //关键是要能对错误进行处理，给一个0x123490 照样能得出 0x9034的值，而且， 占内存要小的

    printf("macro conversion:%#x\n",BSWAP_16(0x123490 ));//要能正确转换

    printf("macro conversion:%#x\n", BSWAP_32(0x1234567890)); //要能正确转换

    
    printf("-----------------\n");
    
    printf("function conversion:%#x\n",bswap16(0x123490)); 
    printf("function conversion:%#x\n", bswap32(0x1234567890));
    
    
    return 0;
}

#include <stdio.h> int main() {     int tt = 1;     char *c = (char*)(&tt);     if(*c == 1)     {         printf("litte endian\n");     }     else     {         printf("big endian\n");     }     return 0; }

 

大小尾端数据间的相互转换


#include <stdio.h>
typedef unsigned int u32;
typedef unsigned short u16;

#define BSWAP_16(x) \
        (u16) ( ((((u16)(x) & 0x00ff)) << 8) \
        | (((u16)(x) & 0xff00) >> 8) )

u16 bswap_16(u16 x)
{
    return ((x & 0x00ff) << 8) | ((x & 0xff00) >> 8);
}

u32 bswap_32(u32 x)
{
    return ((x & 0x000000ff) << 24) |
           ((x & 0x0000ff00) << 8) |
           ((x & 0x00ff0000) >> 8) |
           ((x & 0xff000000) >> 24);
}

int main()
{
     u16 num_16 = 0x1234;
     u32 num_32 = 0x12345678;

    printf("%x\n", bswap_16(num_16));
    printf("%x\n", BSWAP_16(num_16));
    printf("%x\n", bswap_32(num_32));
    return 0;
}

来自:  http://hi.baidu.com/chai_0518/blog/item/417a23d94ded82e138012fd9.html