little endian和big endian的概念解释,判定与用途

converse

little endian和big endian是表示计算机字节顺序的两种格式,所谓的字节顺序指的是长度跨越多个字节的数据的存放形式.
        假设从地址0x00000000开始的一个字中保存有数据0x1234abcd,那么在两种不同的内存顺序的机器上从字节的角度去看的话分别表示为:
       1)little endian:在内存中的存放顺序是0x00000000-0xcd,0x00000001-0xab,0x00000002-0x34,0x00000003-0x12
       2)big  endian:在内存中的存放顺序是0x00000000-0x12,0x00000001-0x34,0x00000002-0xab,0x00000003-0xcd
       需要特别说明的是,以上假设机器是每个内存单元以8位即一个字节为单位的.
       简单的说,ittle endian把低字节存放在内存的低位；而big endian将低字节存放在内存的高位.
       现在主流的CPU,intel系列的是采用的little endian的格式存放数据,而motorola系列的CPU采用的是big endian.
      
       以下是判断字节存储顺序的可移植的C语言代码:

1. 
   
2. /********************************************************************
   
3.         created:        2006-9-5
   
4.         filename:         test.cpp
   
5.         author:                李创
   
6.        
   
7.         purpose:        可移植的用于判断存储格式是
   
8.                 little endian还是big ednian的C代码
   
9.                 取自<<C: A Reference Manual>>
   
10. *********************************************************************/
    
11. 
    
12. #include <stdio.h>
    
13. 
    
14. union
    
15. {
    
16.         long Long;
    
17.         char Char[sizeof(long)];
    
18. }u;
    
19. 
    
20. int main()
    
21. {       
    
22.         u.Long = 1;
    
23.        
    
24.         if (u.Char[0] == 1)       
    
25.         {
    
26.                 printf("Little Endian!\n");
    
27.         }
    
28.         else if (u.Char[sizeof(long) - 1] == 1)
    
29.         {
    
30.                 printf("Big Endian!\n");
    
31.         }
    
32.         else
    
33.         {
    
34.                 printf("Unknown Addressing!\n");
    
35.         }
    
36. 
    
37.     printf("Now, Let's look at every byte in the memory!\n");
    
38.     for (int i = 0; i < sizeof(long); ++i)
    
39.     {
    
40.         printf("[%x] = %x\n", &u.Char[i], u.Char[i]);
    
41.     }
    
42. 
    
43.         return 0;
    
44. }
    

复制代码

很多人认为掌握这个知识是不必要,其实不然.在网络编程中,TCP/IP统一采用big endian方式传送数据,也就是说,假设现在是在一个字节顺序是little endian的机器上传送数据,要求传送的数据是0XCEFABOBO,那么你就要以0XBOBOFACE的顺序在unsigned int中存放这个数据,只有这样才能保证存放的顺序满足TCP/IP的字节顺序要求.很多时候,需要自己编写应用层的协议,字节顺序的概念在这个时候就显得及其的重要了.
       下面给出的是在big endian和little endian中相互转换的代码,C语言强大的位操作的能力在这里显示了出来:

1. 
   
2. /********************************************************************
   
3.         created:        2006-9-5
   
4.         filename:         get32put32.cpp
   
5.         author:                李创
   
6.        
   
7.         purpose:        在little endian和big ednian之间相互转化数据的演示代码
   
8. 
   
9. *********************************************************************/
   
10. 
    
11. 
    
12. #include <stdio.h>
    
13. 
    
14. const unsigned char SIZE_OF_UNSIGNEDINT  = sizeof(unsigned int);
    
15. const unsigned char SIZE_OF_UNSIGNEDCHAR = sizeof(unsigned char);
    
16. 
    
17. void put_32(unsigned char *cmd, unsigned int data)
    
18. {
    
19.     int i;
    
20.     for (i = SIZE_OF_UNSIGNEDINT - 1; i >= 0; --i)
    
21.     {
    
22.         cmd[i] = data % 256;
    
23.         // 或者可以:
    
24.         //cmd[i] = data & 0xFF;
    
25.         data = data >> 8;
    
26.     }
    
27. }
    
28. 
    
29. unsigned int get_32(unsigned char *cmd)
    
30. {
    
31.     unsigned int  ret;
    
32.     int i;
    
33. 
    
34.     for (ret = 0, i = SIZE_OF_UNSIGNEDINT - 1; i >= 0; --i)
    
35.     {
    
36.         ret  = ret << 8;
    
37.         ret |= cmd[i];        
    
38.     }
    
39.        
    
40.     return ret;
    
41. }
    
42. 
    
43. int main(void)
    
44. {
    
45.     unsigned char cmd[SIZE_OF_UNSIGNEDINT];
    
46.     unsigned int data, ret;
    
47.     unsigned char *p;
    
48.     int i;
    
49. 
    
50.     data = 0x12345678;
    
51.     printf("data = %x\n", data);
    
52.     // 以字节为单位打印出数据
    
53.     p = (unsigned char*)(&data);
    
54.     for (i = 0; i < SIZE_OF_UNSIGNEDINT; ++i)
    
55.     {
    
56.         printf("%x", *p++);
    
57.     }
    
58.     printf("\n");
    
59. 
    
60.     // 以相反的顺序存放到cmd之中
    
61.     put_32(cmd, data);
    
62.     for (i = 0; i < SIZE_OF_UNSIGNEDINT; ++i)
    
63.     {
    
64.         printf("cmd[%d] = %x\n", i, cmd[i]);
    
65.     }
    
66. 
    
67.     // 再以相反的顺序保存数据到ret中
    
68.     // 保存之后的ret数值应该与data相同
    
69.     ret = get_32(cmd);
    
70.     printf("ret = %x\n", ret);
    
71.     p = (unsigned char*)(&ret);
    
72.     for (i = 0; i < SIZE_OF_UNSIGNEDINT; ++i)
    
73.     {
    
74.         printf("%x", *p++);
    
75.     }
    
76.     printf("\n");
    
77. 
    
78.     return 0;
    
79. }
    

复制代码

参考资料:<<C: A Reference Manual>>

[ 本帖最后由 converse 于 2006-10-30 17:30 编辑 ]

coldwarm

ittle endian:0xcdab3412,即0x00000000-0xcd,0x00000001-0xab,0x00000002-0x34,0x00000003-0x12

little endian把低位存放到高位

上面的说反了吧.little endian应当是
0x00000000-0x12
0x00000001-0x34
....
这样的吧.

little endian把低字节存放到低地址,把高字节放到高地址.
数据0xcdab3412从左到右,由高字节到低字节,由高地址到低地址.

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. 
   
6. int main()
   
7. {
   
8.     int value = 0x12345678;
   
9. 
   
10.     union ValueT
    
11.     {
    
12.         int value;
    
13.         char data[4];
    
14.     } a;
    
15.     a.value = 0x12345678;
    
16.     printf("value is 0x%x\n", a.value);
    
17.     printf("address is %p, 0x%x\n",&a.data[0], a.data[0]);
    
18.     printf("address is %p, 0x%x\n",&a.data[1], a.data[1]);
    
19.     printf("address is %p, 0x%x\n",&a.data[2],  a.data[2]);
    
20.     printf("address is %p, 0x%x\n", &a.data[3], a.data[3]);
    
21. 
    
22.     exit(EXIT_SUCCESS);
    
23. }
    

复制代码

value is 0x12345678
address is 0xbffffa0c, 0x78
address is 0xbffffa0d, 0x56
address is 0xbffffa0e, 0x34
address is 0xbffffa0f, 0x12

[ 本帖最后由 coldwarm 于 2006-9-5 21:56 编辑 ]

converse

原帖由 coldwarm 于 2006-9-5 21:40 发表
ittle endian:0xcdab3412,即0x00000000-0xcd,0x00000001-0xab,0x00000002-0x34,0x00000003-0x12

little endian把低位存放到高位

上面的说反了吧.little endian应当是
0x00000000-0x12
0x00000001-0x34
. ...

感谢指出错误,我的描述有问题,应该是这样:

       假设从地址0x00000000开始的一个字中保存有数据0x1234abcd,那么在两种不同的内存顺序的机器上从字节的角度去看的话分别表示为:
       1)little endian:在内存中的存放顺序是0x00000000-0xcd,0x00000001-0xab,0x00000002-0x34,0x00000003-0x12
       2)big  endian:在内存中的存放顺序是0x00000000-0x12,0x00000001-0x34,0x00000002-0xab,0x00000003-0xcd

gawk

sun的xdr对字节的转换提供了一整套的函数

connet

socket 中就有现成的，不需要自己写，也不需要什么 xdr
       #include <arpa/inet.h>

       uint32_t htonl(uint32_t hostlong);

       uint16_t htons(uint16_t hostshort);

       uint32_t ntohl(uint32_t netlong);

       uint16_t ntohs(uint16_t netshort);

gawk

hton等函数适用性不是太强l
#include <rpc/xdr.h>

xdr_array(
        XDR *xdrs,
        char **arrp,
        u_int *sizep,
        u_int *maxsize,
        u_int *elsize,
        xdrproc_t elproc );

xdr_bool(
        XDR *xdrs,
        bool_t bp );

xdr_bytes(
        XDR *xdrs,
        char **sp,
        u_int *sizep,
        u_int maxsize );

xdr_char(
        XDR *xdrs,
        char*cp );

void xdr_destroy(
        XDR *xdrs );

xdr_double(
        XDR *xdrs,
        double *dp );

xdr_enum(
        XDR *xdrs,
        enum_t *ep );

xdr_float(
        XDR *xdrs,
        float *fp );

void xdr_free(
        xdrproc_t proc,
        char *objp );

u_int xdr_getpos(
        XDR *xdrs );

xdr_hyper(
        XDR *xdrs,
        longlong_t *hp );

long *xdr_inline(
        XDR *xdrs,
        int len );

xdr_int(
        XDR *xdrs,
        int *ip );

xdr_long(
        XDR *xdrs,
        long *lp );

xdr_longlong_t(
        XDR *xdrs,
        longlong_t *hp );

xdr_opaque(
        XDR *xdrs,
        char *cp,
        u_int cnt );

xdr_pmap(
        XDR *xdrs,
        struct pmap *regs );

xdr_pmaplist(
        XDR *xdrs,
        struct pmaplist **rp );

xdr_pointer(
        XDR *xdrs,
        char **objpp,
        u_int objsize,
        xdrproc_t xdrobj );

xdr_reference(
        XDR *xdrs,
        char **pp,
        u_int size,
        xdrproc_t proc );

xdr_setpos(
        XDR *xdrs,
        u_int pos );

xdr_short(
        XDR *xdrs,
        short *sp );

xdr_string(
        XDR *xdrs,
        char **sp,
        u_int maxsize );

xdr_u_char(
        XDR *xdrs,
        unsigned char *ucp );

xdr_u_hyper(
        XDR *xdrs,
        u_longlong_t *uhp );

xdr_u_int(
        XDR *xdrs,
        unsigned *up );

xdr_u_long(
        XDR *xdrs,
        unsigned long *ulp );

xdr_u_longlong_t(
        XDR *xdrs,
        u_longlong_t *uhp );

xdr_u_short(
        XDR *xdrs,
        unsigned short *usp );

xdr_union(
        XDR *xdrs,
        int *dscmp,
        char *unp,
        struct xdr_discrim *choices,
        bool_t (*defaultarm) (void) );

xdr_vector(
        XDR *xdrs,
        char *arrp,
        u_int size,
        u_int elsize,
        xdrproc_t elproc );

xdr_void(
        void );

xdr_wrapstring(
        XDR *xdrs,
        char **sp );

void xdrmem_create(
        XDR *xdrs,
        char *addr,
        u_int size,
        enum xdr_op op );

void xdrrec_create(
        XDR *xdrs,
        u_int sendsize,
        u_int recvsize,
        char *handle,
        int (*readit) (void),
        int (*writeit) (void) );
这个基本上涵盖了各种类型

snowoak

代码应该是：

1. 
   
2. if  (u.Char[ 0 ]  ==   1 )   
   
3.       {
   
4.         printf( " [color=Red]Big[/color] Endian!\n " );
   
5.     }
   
6.      else   if  (u.Char[ sizeof ( long )  -   1 ]  ==   1 )
   
7.       {
   
8.         printf( " [color=Red]little[/color] Endian!\n " );
   
9.     }
   
10. 
    

复制代码

[ 本帖最后由 snowoak 于 2006-9-15 12:11 编辑 ]

sway2004009

原帖由 snowoak 于 2006-9-15 11:58 发表
还是有问题吧，应该是：
little endian：
0x00000000：0x12
……
0x00000003：0xcd

big endian：
0x00000000：0xcd
……
0x00000003：0x12

是你自己的那个有问题，同意lz的说法

snowoak

原帖由 sway2004009 于 2006-9-15 12:10 发表


是你自己的那个有问题，同意lz的说法

呵呵，我知道是我的问题了：）

chb79

原帖由 converse 于 2006-9-5 21:12 发表
简单的说,little endian把低位存放到高位,而big endian把低位存放到低位.

这个总结错了吧，应该是
little endian把低字节存放在内存的低位；而big endian将低字节存放在内存的高位。

0x1234adcd中，0xcd算是低字节