内存对齐问题

zxrjkl

在struct、class中编译器会进行内存对齐，如

1. #include <stdio.h>
   
2. typedef struct
   
3. {
   
4. char a;
   
5. int b;
   
6. int c;
   
7. } A;
   
8. typedef struct
   
9. {
   
10. char a;
    
11. short b;
    
12. int c;
    
13. } B;
    
14. int main()
    
15. {
    
16. printf("%d\t%d\n", sizeof(A), sizeof(B));
    
17. return 0;
    
18. }
    

复制代码

结果是：12    8
但为什么short的对齐是2而不是int的4；（对齐方式是与sizeof成正比）
为什么这样对齐效率才高？

yulihua49

回复  star1983653
我的是64位的系统，应该能度8字节吧；
这样的话就对齐到8字节如何呢？
zxrjkl 发表于 2010-04-26 16:13

不一定。有时是1字节，有时是2字节，有时是4、8、16字节（如long double类型）。
看我上边的程序，max_allign就是用来记录结构中最大的成员。

yulihua49

typedef struct

{

char a;

short b;

int c;

} B;


这个short不是紧接着char a 后面的， ...
deanshuai 发表于 2010-04-26 21:01

32位linux的double是4字节对齐，64位是8字节对齐。
给你一个边界对齐的计算程序：这个程序用于分析未知结构的成员，数量类型，长度，位置（边界对齐），格式和整个结构的尺寸。

1. 
   
2. 
   
3. #include <pack.h>
   
4. 
   
5. #define M_ST_OFF(struct_type, member)    \
   
6.         (int)((void *) &(((struct_type*) 0)->member))
   
7. //这些结构用来测试各种数据的边界对齐规则，不要猜，要让编译器自己说。
   
8. typedef struct {
   
9.     char a;
   
10.     long b;
    
11. } align;
    
12. typedef struct {
    
13.     char a;
    
14.     double b;
    
15. } dalign;
    
16. typedef struct {
    
17.     char a;
    
18.     long double b;
    
19. } dfali;
    
20. typedef struct {
    
21.     char a;
    
22.     INT64 b;
    
23. } lfali;
    
24. 
    
25. int set_offset(T_PkgType *pkg_type)
    
26. {
    
27. int i,k;
    
28. int ali,dali,lali,ldli;
    
29. int max_allign=1;
    
30. 
    
31.     if(pkg_type->offset>-1) return cnt_type(pkg_type);
    
32.     ali= M_ST_OFF(align,b) - 1;
    
33.     dali=M_ST_OFF(dalign,b) - 1;
    
34.     lali= M_ST_OFF(lfali,b) - 1;
    
35.     ldli= M_ST_OFF(dfali,b) - 1;
    
36.     k=0;
    
37.     for(i=0;pkg_type[i].type>-1;i++){
    
38.         pkg_type[i].offset=k;
    
39.         pkg_type[i].bindtype=0;
    
40.         if((pkg_type[i].type&127)!=CH_CLOB)k+=pkg_type[i].len;
    
41.         else k+=sizeof(char *);
    
42.         switch(pkg_type[i+1].type&127) {
    
43.             case 127:
    
44.             case CH_CHAR:
    
45.             case CH_BYTE:
    
46.             case CH_TINY:
    
47.                 break;
    
48.             case CH_INT64:
    
49.                 k=(k+lali)&~lali;
    
50.                 max_allign=(max_allign>sizeof(INT64))?max_allign:sizeof(INT64);
    
51.                 break;
    
52.             case CH_LDOUBLE:
    
53.                 k=(k+ldli)&~ldli;
    
54.                 break;
    
55.             case CH_DOUBLE:
    
56.                 k=(k+dali)&~dali;
    
57.                 max_allign=(max_allign>sizeof(double))?max_allign:sizeof(double);
    
58.                 break;
    
59.             case CH_SHORT:
    
60.                 k=(k+1)&~1;
    
61.                 max_allign=(max_allign>sizeof(short))?max_allign:sizeof(short);
    
62.                 break;
    
63.             case CH_CLOB:
    
64.                 k=(k+(sizeof(char *)-1)) & ~(sizeof(char *)-1);
    
65.                 max_allign=(max_allign>sizeof(char *))?max_allign:sizeof(char *);
    
66.                 break;
    
67.             case CH_FLOAT:
    
68.             case CH_INT:
    
69.                 k=(k+3)&~3;
    
70.                 max_allign=(max_allign>sizeof(int))?max_allign:sizeof(int);
    
71.                 break;
    
72.             case CH_LONG:
    
73.                 max_allign=(max_allign>sizeof(long))?max_allign:sizeof(long);
    
74.             default:
    
75.                 k=(k+ali)&~ali;
    
76.                 break;
    
77.         }
    
78.     }
    
79. // 2009-06-22 by ylh,adjuct to struct align
    
80. //  pkg_type[i].offset=(k+ali)&~ali;
    
81.     if(max_allign>1) {
    
82.         max_allign--;
    
83.         pkg_type[i].offset=(k+max_allign)&~max_allign;
    
84.     }
    
85.     pkg_type[i].bindtype=0;
    
86.     return i;
    
87. }
    
88. 
    
89. pack.h的部分内容：
    
90. #include <sys/types.h>
    
91. #include <datejul.h>
    
92. 
    
93. #define CH_BYTE 0
    
94. #define CH_CHAR 1
    
95. #define CH_TINY 2
    
96. #define CH_SHORT 3
    
97. #define CH_INT 4
    
98. #define CH_LONG 5
    
99. #define CH_INT64 6
    
100. #define CH_FLOAT 7
     
101. #define CH_DOUBLE 8
     
102. #define CH_LDOUBLE 9
     
103. #define CH_CLOB 126
     
104. 
     
105. extern const char NAN[sizeof(double)];
     
106. #define DOUBLENULL (*(double *)NAN)
     
107. #define FLOATNULL (*(float *)NAN)
     
108. #define SHORTNULL (short)(1<<(8*sizeof(short)-1))
     
109. #define INTNULL   (int)(1<<(8*sizeof(int)-1))
     
110. #define LONGNULL  (1L<<(8*sizeof(long)-1))
     
111. #define INT64NULL  ((INT64)1<<(8*sizeof(INT64)-1))
     
112. #define TINYNULL  0X80
     
113. 
     
114. 
     
115. /*****************************************************
     
116. * define extend data type for net_pack()
     
117. *****************************************************/
     
118. #define CH_DATE     CH_CHAR|0x80
     
119. #define CH_CNUM     CH_CHAR|0x100
     
120. #define CH_JUL      CH_INT4|0X80
     
121. #define CH_MINUTS   CH_INT4|0x100
     
122. #define CH_TIME     CH_INT64|0x80
     
123. #define CH_USEC     CH_INT64|0x200
     
124. /* used by varchar2 as date(year to day),default format is "YYYYMMDD" */
     
125. #define CH_CJUL     CH_INT4|0x200
     
126. #define CH_CMINUTS  CH_INT4|0x400
     
127. /* used by varchar2 as date(year to sec),default format is "YYYYMMDDHH24MISS" */
     
128. #define CH_CTIME    CH_INT64|0x100
     
129. //这个就是所谓的“模板”了，它使我们能够"看"到未知结构的内容。
     
130. typedef struct {
     
131.         INT4 type;
     
132.         INT4 len; // in byte
     
133.         char *name;
     
134.         const char *format;
     
135.         INT4 offset;
     
136.         int bindtype; //default=0
     
137. } T_PkgType;
     
138. // for bindtype
     
139. #define RETURNING 1     //this column only for returnning
     
140. #define NOINS     2 //this column don't insert or update
     
141. #define NOSELECT  4     //this column don't select only used by bind
     
142. 
     
143. 
     
144. 
     

复制代码

以上就是 结构-关系映像（SRM，Struct Relational mapping) 最核心的内容。SRM完成把结构的内容与字符串互相映像（结构变字符串，也叫序列化，字符串变结构，也叫反序列化；
结构内容进入数据库表，数据库表的内容进入结构；JSON与结构的互相映射等等。

yulihua49

在struct、class中编译器会进行内存对齐，如结果是：12    8
但为什么short的对齐是2而不是int的4；（对齐 ...
zxrjkl 发表于 2010-04-26 13:42

  sizeof(struct)与边界对齐并不完全等同。
sizeof以结构中最大尺寸的成员（不包括结构）的尺寸对齐。

变异老鼠

回复 15# zxrjkl


    如果一个 2 字节区域不作对齐，是可以跨越两个 8 字节对齐的单元的。

zxrjkl

回复 13# 变异老鼠
那我就算不对齐也可以一次读入

deanshuai

typedef struct

{

char a;

short b;

int c;

} B;


这个short不是紧接着char a 后面的，应该是空一个字节。我之前在linux测试过double对齐问题，发现linux下，doubule也是4字节对齐。应该是编译做了优化。

变异老鼠

回复 11# zxrjkl


    一块 2 字节的内存空间，只要它是 2 字节对齐的，就必然在某个 8 字节对齐的 8 字节内存空间内，而这个 8 字节空间是可以一次读入的。所以盲目扩大对齐要求，不但不会加速，反而浪费空间。

star1983653

你编译出的程序是32位的，即使CPU是64位的也没有用。纯属浪费！

zxrjkl

回复 10# star1983653
我的是64位的系统，应该能度8字节吧；
这样的话就对齐到8字节如何呢？