Chinaunix首页 | 论坛 | 博客

aaron20127的ChinaUnix博客

首页　| 　博文目录　| 　关于我

aaron20127

  • 博客访问： 315140
  • 博文数量： 82
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 490
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-13 10:58
文章分类

全部博文（82）

文章存档

2018年（2）

2017年（9）

2016年（71）

我的朋友
最近访客
推荐博文
相关博文
C语言中字节对齐和位域

分类： C/C++

2016-12-04 11:04:37

1.1 基本类型默认字节对齐和改变字节对齐方式

 c语言在给不同类型变量分配地址空间时，并不是总是紧邻着上一个变量的地址空间分配的，而是它所在的地址空间，必须被它的默认对齐字节数整除。例如，int类型占4字节，其默认对齐字节数为4，那么它所在的地址的低4位必须为0x0、0x4、0x8和0xc，因为这些地址才能被4整除；又如short类型，其本身占2字节，默认对齐字节数为2，则其地址的低4位必须为0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe；那么char型就不用说了，他可以分配在任意地址。我们可以通过alignas()改变类型的对齐方式，通过alignof()获取类型的默认对齐大小，这两个参数在stdalign.h头文件中。示例如下：

  1. #include <stdio.h>
  2. #include <stdalign.h>

  4. int main(int argc, char * argv[])
  5. {

  7.     char a;
  8.     int b;
  9.     short c;
  10.     alignas(double) char d;
  11.     char e;
  12.     
  13.     printf("&a [%p]\n", &a);
  14.     printf("&b [%p]\n", &b);
  15.     printf("&c [%p]\n", &c);
  16.     printf("&d [%p]\n", &d);
  17.     printf("&e [%p]\n", &e);

  19.     printf("sizeof(d) [%d]\n", sizeof(d));
  20.     printf("alignof(char) [%d]\n", alignof(char));
  21.     printf("alignof(short) [%d]\n", alignof(short));
  22.     printf("alignof(int) [%d]\n", alignof(int));

  24.     return 0;
  25. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./main
  2. &a [0xbfed301f]
  3. &b [0xbfed3018]
  4. &c [0xbfed3016]
  5. &d [0xbfed3010] //d分配了一个8字节对齐的地址空间，但并未分配8个字节的内存给d
  6. &e [0xbfed300f]
  7. sizeof(d) [1] //d占得空间大小未变
  8. alignof(char) [1]
  9. alignof(short) [2]
  10. alignof(int) [4]

  从结果中可以看到地址的分配顺序是从a到e分配的，地址从高到低。如果是从e到a分配的话，c的地址应该为0xbfed3012，因为c是short类型，只占两个字节。虽然d的对齐方式为double，但它实际占用的内存也只为1字节，只是给它分配地址方式必须和double一样，按8字节对齐方式分配，所以这里c和d只相差了6个字节。
 

1.2 字节对齐的好处

  第一个好处是加快读取速度，拿32位机来说，它一次从内存读取4字节数据，都是从能被4整除的地址开始读取的。当一个4字节int型刚好按默认字节对齐时，那么32位机一次就刚好能将该整型读走，因为它们刚好对齐。如果这个int型刚好分配在0x02-0x5地址处，则32位机必须先读走0x00-0x03地址的数据，再读走0x04-0x07数据之后将0x02-0x03和0x04-0x05地址数据拼接在一起才能得到该int型的实际数据。在这里前者快了一倍的速度。

  第二个好处是可以节省内存，比如可以将所有数据紧挨在一起，但这样降低了运行效率，后面将会讲到如何使数据紧挨到一起分配。
 

1.3 复合数据类型对齐以及改变其对齐方式

  除了基本类型之外，复合类型如结构体和联合等都能改变其默认对齐方式，gcc通常默认的对齐方式为4字节。可以改变对齐方式有下边几种方法：

（1）#pragma pack(n)   //编译时，使对齐方式为n。n必须是2的幂指数，且n只有在小于结构体成员的最大默认对齐字节数才生效。就是只能用来减小对齐方式。

#pragma pack()    //恢复默认对齐方式

 

（2）#pragma pack(push, n)   //保存以前设置的对齐方式，并使当前对齐方式变成n

#pragma pack(pop)      //恢复到之前的对齐方式

注意：#pragma pack(push, n)等价于#pragma pack(push); #pragma pack(n)


示例：

  1. #include <stdio.h>
  2. #include <string.h>


  5. int main()
  6. {
  7.     struct fo1 { //默认4字节对齐
  8.         char a;
  9.         int b;
  10.         short c;
  11.     }foo1;

  13. #pragma pack(2) //设置成两字节对齐

  15.     struct fo2 {
  16.         char a;
  17.         int b;
  18.         short c;
  19.     }foo2;

  21. #pragma pack(push, 1) //保存两字节对齐状态，设置成1字节对齐

  23.     struct fo3 {
  24.         char a;
  25.         int b;
  26.         short c;
  27.     }foo3;

  29. #pragma pack(pop) //恢复到之前的字节对齐方式，为两字节对齐

  31.     struct fo4 {
  32.         char a;
  33.         int b;
  34.         short c;
  35.     }foo4;

  37. #pragma pack() //还原到默认4字节对齐方式

  39.     struct fo5 {
  40.         char a;
  41.         int b;
  42.         short c;
  43.     }foo5;

  45. #pragma pack(8) //设置成8字节对齐方式

  47.     struct fo6 {
  48.         char a;
  49.         int b;
  50.         short c;
  51.     }foo6;

  53. #pragma pack()

  55.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));
  56.     printf("&foo1.a [%p]\n", &foo1.a);
  57.     printf("&foo1.b [%p]\n", &foo1.b);
  58.     printf("&foo1.c [%p]\n", &foo1.c);

  60.     printf("\nsizeof(foo2) [%zd]\n", sizeof(foo2));
  61.     printf("&foo2.a [%p]\n", &foo2.a);
  62.     printf("&foo2.b [%p]\n", &foo2.b);
  63.     printf("&foo2.c [%p]\n", &foo2.c);

  65.     printf("\nsizeof(foo3) [%zd]\n", sizeof(foo3));
  66.     printf("&foo3.a [%p]\n", &foo3.a);
  67.     printf("&foo3.b [%p]\n", &foo3.b);
  68.     printf("&foo3.c [%p]\n", &foo3.c);

  70.     printf("\nsizeof(foo4) [%zd]\n", sizeof(foo4));
  71.     printf("&foo4.a [%p]\n", &foo4.a);
  72.     printf("&foo4.b [%p]\n", &foo4.b);
  73.     printf("&foo4.c [%p]\n", &foo4.c);

  75.     printf("\nsizeof(foo5) [%zd]\n", sizeof(foo5));
  76.     printf("&foo5.a [%p]\n", &foo5.a);
  77.     printf("&foo5.b [%p]\n", &foo5.b);
  78.     printf("&foo5.c [%p]\n", &foo5.c);
  79.     
  80.     printf("\nsizeof(foo6) [%zd]\n", sizeof(foo6));
  81.     printf("&foo6.a [%p]\n", &foo6.a);
  82.     printf("&foo6.b [%p]\n", &foo6.b);
  83.     printf("&foo6.c [%p]\n", &foo6.c);

  85.     return 0;
  86. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. sizeof(foo1) [12] //默认4字节对齐时占了12字节
  3. &foo1.a [0xbfae9b84] //a占了1个字节，a与b之间有3个字节未用
  4. &foo1.b [0xbfae9b88] //b占了4个字节，与c之间 空隙
  5. &foo1.c [0xbfae9b8c] //c占了两个字节，为补满4字节，后有两个空字节

  7. sizeof(foo2) [8] //默认2字节对齐
  8. &foo2.a [0xbfae9b7c] //a占2字节
  9. &foo2.b [0xbfae9b7e] //b占4字节
  10. &foo2.c [0xbfae9b82] //c占2字节

  12. sizeof(foo3) [7] //保存了2字节对齐的状态，当前1字节对齐
  13. &foo3.a [0xbfae9b75] //a占1字节
  14. &foo3.b [0xbfae9b76] //b占4字节
  15. &foo3.c [0xbfae9b7a] //c占2字节

  17. sizeof(foo4) [8] //恢复到2字节对齐
  18. &foo4.a [0xbfae9b6c]
  19. &foo4.b [0xbfae9b6e]
  20. &foo4.c [0xbfae9b72]

  22. sizeof(foo5) [12] //恢复到4字节对齐
  23. &foo5.a [0xbfae9b60]
  24. &foo5.b [0xbfae9b64]
  25. &foo5.c [0xbfae9b68]

  27. sizeof(foo6) [12] //设置成8字节对齐，未生效
  28. &foo6.a [0xbfae9b54]
  29. &foo6.b [0xbfae9b58]
  30. &foo6.c [0xbfae9b5c]
  从结果中可以看到，foo6并没有变成8字节对齐。原因是foo6结果中最大字节对齐的成员为int，为4字节对齐，它比8字节小，所以不能对齐成8字节。这里说明了#pragma pack()只能减小字节对齐。

（3）__attribute__((__packed__))  //取消字节优化对齐，即都是1字节对齐

__attribute__((packed))    //同上 

示例：

  1. #include <stdio.h>
  2. #include <string.h>

  4. int main()
  5. {
  6.     typedef struct {
  7.         char a;
  8.         int b;
  9.         short c;
  10.     }__attribute__((__packed__)) fo1;
  11.     
  12.     typedef struct {
  13.         char a;
  14.         int b;
  15.         short c;
  16.     }__attribute__((packed)) fo2;
  17.     
  18.     typedef struct {
  19.         char a;
  20.         int b;
  21.         short c;
  22.     }fo3;
  23.     
  24.     fo1 foo1;
  25.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));
  26.     printf("&foo1.a [%p]\n", &foo1.a);
  27.     printf("&foo1.b [%p]\n", &foo1.b);
  28.     printf("&foo1.c [%p]\n", &foo1.c);

  30.     fo2 foo2;
  31.     printf("\nsizeof(foo2) [%zd]\n", sizeof(foo2));
  32.     printf("&foo2.a [%p]\n", &foo2.a);
  33.     printf("&foo2.b [%p]\n", &foo2.b);
  34.     printf("&foo2.c [%p]\n", &foo2.c);
  35.     
  36.     
  37.     fo3 foo3;
  38.     printf("\nsizeof(foo3) [%zd]\n", sizeof(foo3));
  39.     printf("&foo3.a [%p]\n", &foo3.a);
  40.     printf("&foo3.b [%p]\n", &foo3.b);
  41.     printf("&foo3.c [%p]\n", &foo3.c);

  43.     return 0;
  44. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. sizeof(foo1) [7]
  3. &foo1.a [0xbf8ea529] //a占1字节
  4. &foo1.b [0xbf8ea52a] //b占4字节
  5. &foo1.c [0xbf8ea52e] //c占2字节

  7. sizeof(foo2) [7]
  8. &foo2.a [0xbf8ea522]
  9. &foo2.b [0xbf8ea523]
  10. &foo2.c [0xbf8ea527]

  12. sizeof(foo3) [12]
  13. &foo3.a [0xbf8ea514]
  14. &foo3.b [0xbf8ea518]
  15. &foo3.c [0xbf8ea51c]

（4）__attribute__((aligned(n)))  //该参数并不会改变每个成员的默认对齐方式，而是将变量占用的空间大小指定为n的整数倍，空字节用于填充，且变量的首地址也必须被n整除。只有当n大于结构体成员的最大对齐字节数时才有效，n为2的幂指数。当然，该参数对于基本变量也有效。

  __attribute__((aligned))     //自动选择最有益的方式对齐，可以提高拷贝操作的效率。此处意义不明？

 __attribute__((__aligned__))  //同上

 

示例：

  1. #include <stdio.h>
  2. #include <string.h>

  4. int main()
  5. {
  6.     typedef struct {
  7.         char a;
  8.         char b;
  9.         char c;
  10.     }__attribute__((aligned)) fo1;
  11.     
  12.     typedef struct {
  13.         char a;
  14.         int b;
  15.         short c;
  16.     }__attribute__((__aligned__)) fo2;
  17.     
  18.     typedef struct {
  19.         char a;
  20.         int b;
  21.         short c;
  22.     }__attribute__((aligned(512))) fo3;

  24.     typedef struct {
  25.         char a;
  26.         int b;
  27.         short c;
  28.     }__attribute__((aligned(1))) fo4;

  30.     fo1 foo1;
  31.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));
  32.     printf("&foo1.a [%p]\n", &foo1.a);
  33.     printf("&foo1.b [%p]\n", &foo1.b);
  34.     printf("&foo1.c [%p]\n", &foo1.c);

  36.     fo2 foo2;
  37.     printf("\nsizeof(foo2) [%zd]\n", sizeof(foo2));
  38.     printf("&foo2.a [%p]\n", &foo2.a);
  39.     printf("&foo2.b [%p]\n", &foo2.b);
  40.     printf("&foo2.c [%p]\n", &foo2.c);
  41.     
  42.     
  43.     fo3 foo3;
  44.     printf("\nsizeof(foo3) [%zd]\n", sizeof(foo3));
  45.     printf("&foo3.a [%p]\n", &foo3.a);
  46.     printf("&foo3.b [%p]\n", &foo3.b);
  47.     printf("&foo3.c [%p]\n", &foo3.c);

  49.     fo4 foo4;
  50.     printf("\nsizeof(foo4) [%zd]\n", sizeof(foo4));
  51.     printf("&foo4.a [%p]\n", &foo4.a);
  52.     printf("&foo4.b [%p]\n", &foo4.b);
  53.     printf("&foo4.c [%p]\n", &foo4.c);


  56.     char a ;
  57.     char b __attribute__((__aligned__));
  58.     char c;

  60.     printf("\n&a [%p]\n", &a);
  61.     printf("&b [%p]\n", &b);
  62.     printf("&c [%p]\n", &c);    
  63.     return 0;
  64. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. sizeof(foo1) [16]
  3. &foo1.a [0xbfa16df0]
  4. &foo1.b [0xbfa16df1]
  5. &foo1.c [0xbfa16df2]

  7. sizeof(foo2) [16]
  8. &foo2.a [0xbfa16de0]
  9. &foo2.b [0xbfa16de4]
  10. &foo2.c [0xbfa16de8]

  12. sizeof(foo3) [512]
  13. &foo3.a [0xbfa16a00]
  14. &foo3.b [0xbfa16a04]
  15. &foo3.c [0xbfa16a08]

  17. sizeof(foo4) [12]
  18. &foo4.a [0xbfa169f4]
  19. &foo4.b [0xbfa169f8]
  20. &foo4.c [0xbfa169fc]

  22. &a [0xbfa169f3]
  23. &b [0xbfa169f0] // __attribute__((__aligned__))
  24. &c [0xbfa169ef]

从示例中可以看出foo2和foo1都自动优化成了4字节对齐，foo3变成512字节对齐，foo4没有生效。因为foo4的对齐小于成员的最大对齐字节数。关于变量abc的地址关系，表示没看懂，没搞懂这个优化是什么意思。


1.4 结构体中变量的排列方式对字节对齐的影响

  在结构体中不同类型成员的位置关系也会影响结构体所占空间的大小，合理的为结构体成员排序可以起到节省内存的作用。我们可以看一下下边的例子：

  1. #include <stdio.h>
  2. #include <string.h>

  4. int main()
  5. {
  6.     
  7.     typedef struct {
  8.         char a;
  9.         int b;
  10.         short c;
  11.     } fo1;
  12.     
  13.     typedef struct {
  14.         int a;
  15.         short b;
  16.         char c;
  17.     } fo2;

  19.     typedef struct { //使用pad填充结构体中的空隙
  20.         char a;
  21.         char pad[3];
  22.         int b;
  23.         short c;
  24.         char pad1[2];
  25.     } fo3;
  26.     
  27.     typedef struct { //使用pad填充结构体中的空隙
  28.         int a;
  29.         short b;
  30.         char c;
  31.         char pad[1];
  32.     } fo4;

  34.     fo1 foo1;
  35.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));
  36.     printf("&foo1.a [%p]\n", &foo1.a);
  37.     printf("&foo1.b [%p]\n", &foo1.b);
  38.     printf("&foo1.c [%p]\n", &foo1.c);

  40.     fo2 foo2;
  41.     printf("\nsizeof(foo2) [%zd]\n", sizeof(foo2));
  42.     printf("&foo2.a [%p]\n", &foo2.a);
  43.     printf("&foo2.b [%p]\n", &foo2.b);
  44.     printf("&foo2.c [%p]\n", &foo2.c);

  46.     fo3 foo3;
  47.     printf("\nsizeof(foo3) [%zd]\n", sizeof(foo3));
  48.     printf("&foo3.a [%p]\n", &foo3.a);
  49.     printf("&foo3.pad[0] [%p]\n", &foo3.pad[0]);
  50.     printf("&foo3.pad[1] [%p]\n", &foo3.pad[1]);
  51.     printf("&foo3.pad[2] [%p]\n", &foo3.pad[2]);
  52.     printf("&foo3.b [%p]\n", &foo3.b);
  53.     printf("&foo3.c [%p]\n", &foo3.c);
  54.     printf("&foo3.pad1[0] [%p]\n", &foo3.pad1[0]);
  55.     printf("&foo3.pad1[1] [%p]\n", &foo3.pad1[1]);

  57.     fo4 foo4;
  58.     printf("\nsizeof(foo4) [%zd]\n", sizeof(foo4));
  59.     printf("&foo4.a [%p]\n", &foo4.a);
  60.     printf("&foo4.b [%p]\n", &foo4.b);
  61.     printf("&foo4.c [%p]\n", &foo4.c);
  62.     printf("&foo4.pad[0] [%p]\n", &foo4.pad[0]);

  64.     return 0;
  65. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. sizeof(foo1) [12]
  3. &foo1.a [0xbf8db714]
  4. &foo1.b [0xbf8db718]
  5. &foo1.c [0xbf8db71c]

  7. sizeof(foo2) [8]
  8. &foo2.a [0xbf8db70c]
  9. &foo2.b [0xbf8db710]
  10. &foo2.c [0xbf8db712]

  12. sizeof(foo3) [12]
  13. &foo3.a [0xbf8db700]
  14. &foo3.pad[0] [0xbf8db701] //pad刚好填充了a与b中的空隙
  15. &foo3.pad[1] [0xbf8db702]
  16. &foo3.pad[2] [0xbf8db703]
  17. &foo3.b [0xbf8db704]
  18. &foo3.c [0xbf8db708]
  19. &foo3.pad1[0] [0xbf8db70a] //pad1刚好填充了c后边的空隙
  20. &foo3.pad1[1] [0xbf8db70b]

  22. sizeof(foo4) [8]
  23. &foo4.a [0xbf8db6f8]
  24. &foo4.b [0xbf8db6fc]
  25. &foo4.c [0xbf8db6fe]
  26. &foo4.pad[0] [0xbf8db6ff]

  从上边的例子可以看出，由于默认地址4字节的对齐属性，导致了foo1和foo2中都有未使用到的空间。foo3和foo4使用pad填充并证实了这些空隙。还可以看出不同成员变量的位置不一样，占用的空间不一样，这里也许可以得到这个结论，将结构体成员中对齐字节数高的变量从大到小依次排列，可以减小结构体所占用的内存。当然，这种方法应该只对部分情况奏效。


1.5 结构体成员中有结构体时字节对齐对其的影响

  如果改变了某个结构体的默认对齐方式，且该结构体成员中有结构体变量，那么这种对齐方式的改变不会影响结构体成员。可以通过以下示例得到证明：

  1. #include <stdio.h>
  2. #include <string.h>

  4. void hex_printf(unsigned char * buff, int len)
  5. {
  6.     for (int i = 0; i < len; i++) {
  7.         printf("%02hhx ", buff[i]);
  8.         if ((i+1) % 16 == 0) {
  9.             printf("\n");
  10.         }
  11.     }
  12.     printf("\n");
  13. }

  15. int main()
  16. {
  17.     typedef struct {
  18.         char a;
  19.         int b;
  20.         short c;
  21.     } fo;
  22.     
  23.     typedef struct {
  24.         int a;
  25.         short b;
  26.         char c;
  27.         fo d;
  28.     } fo1;

  30. #pragma pack(1) //一字节对齐
  31.     typedef struct {
  32.         int a;
  33.         short b;
  34.         char c;
  35.         fo d;
  36.     } fo2;
  37. #pragma pack()


  40.     fo1 foo1;
  41.     memset(&foo1, 0, sizeof(foo1));
  42.     foo1.a = 1;
  43.     foo1.b = 2;
  44.     foo1.c = 3;
  45.     foo1.d.a = 4;
  46.     foo1.d.b = 5;
  47.     foo1.d.c = 6;
  48.     
  49.     hex_printf(&foo1, sizeof(foo1));
  50.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));

  52.     fo2 foo2;
  53.     memset(&foo2, 0, sizeof(foo2));
  54.     foo2.a = 1;
  55.     foo2.b = 2;
  56.     foo2.c = 3;
  57.     foo2.d.a = 4;
  58.     foo2.d.b = 5;
  59.     foo2.d.c = 6;

  61.     printf("\n");
  62.     hex_printf(&foo2, sizeof(foo2));
  63.     printf("sizeof(foo2) [%zd]\n", sizeof(foo2));

  65.     return 0;
  66. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. 01 00 00 00 02 00 03 00 04 00 00 00 05 00 00 00
  3. 06 00 00 00
  4. sizeof(foo1) [20] //foo1中abc占了8字节，d占了12字节

  6. 01 00 00 00 02 00 03 04 00 00 00 05 00 00 00 06
  7. 00 00 00
  8. sizeof(foo2) [19] //foo1中的abc安一字节对齐了，而d未受影响

  从结果可以看出，foo1的实际大小是foo1除了结构体成员以外的其他成员对齐以后占空间的大小加上结构体成员自身对齐后占空间的大小。且改变结构体对齐方式，并不会影响其结构体成员。


1.6 位域

  结构体的最小成员还可以是bit位，可以将单个整型的不同位组合成多个变量成员。我们可以参考下边的示例：

  1. #include <stdio.h>
  2. #include <string.h>

  4. void hex_printf(unsigned char * buff, int len)
  5. {
  6.     for (int i = 0; i < len; i++) {
  7.         printf("%02hhx ", buff[i]);
  8.         if ((i+1) % 16 == 0) {
  9.             printf("\n");
  10.         }
  11.     }
  12.     printf("\n");
  13. }

  15. int main()
  16. {
  17.     typedef struct bitbox {
  18.         unsigned int a:1;    
  19.         unsigned int :3; //占位，表示紧邻的3个位不使用
  20.         unsigned int b:4;
  21.         unsigned int c:1;
  22.         unsigned int :0; //将unsigned int的剩下所有位都填满
  23.         unsigned int d:1; //从下一个unsigned int中分配1位给d
  24.     }fo1;

  26.     fo1 foo1;
  27.     memset(&foo1, 0, sizeof(foo1));
  28.     foo1.a = 1;
  29.     foo1.b = 3;
  30.     foo1.c = 1;
  31.     foo1.d = 1;
  32.     
  33.     hex_printf(&foo1, sizeof(foo1));
  34.     printf("sizeof(foo1) [%zd]\n", sizeof(foo1));

  36.     return 0;
  37. }
结果：gcc version 4.8.1 (GCC)
  1. [root@192 util]# ./a.out
  2. 31 01 00 00 01 00 00 00
  3. sizeof(foo1) [8]

  从打印结果来看这是一个小端机，即低字节存储在低地址中。第一个字节是0x31，其中存储了a、b的值和3个空位。从二进制00110001来看，b和a是倒序排列的，即不是按结构体中的顺序排列在一字节上的。从第五个字节可以看到，d存储在第二个unsigned int中，说明了unsigned int :0确实将第一个unsigned int中未使用的位全部填充了。

参考资料：
  http://blog.csdn.net/markl22222/article/details/38051483 
  http://www.cnblogs.com/ransn/p/5081198.html 
  http://blog.csdn.net/mylinx/article/details/7007309 
  http://blog.csdn.net/jnu_kinke/article/details/7420185

阅读(3058) | 评论(0) | 转发(0) |
0

上一篇：C语言判断大小端机以及区分大小端机变量在内存中的排序方式

下一篇：c语言原码、反码和补码和符号变量移位

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6