内存地址的对齐

From:http://blog.youkuaiyun.com/cg05568256068/archive/2009/04/17/4086451.aspx

内存地址的对齐主要考虑三个因素：

1：对于每个成员的起始地址是他本身所占的整数倍

2：整个所占的内存是成员中占的地址内存最多的整数倍

3：有#pragma pack(int)进行设置,如果结构体某成员的sizeof大于你设置的，则按你的设置来对齐

注意：每次用#pragma pack(int)进行设置后，要用#pragma pack()对其结束，免得造成错误

view plain copy to clipboard print ?

1. #include<iostream>
2. usingnamespacestd;
4. structA
5. {
6. inta;//0123
7. charb;//4*
8. shortc;//67
9. };
11. structB
12. {
13. chara;//0***
14. intb;//4567
15. shortc;//89**
16. };
18. #pragmapack(2)
19. structC
20. {
21. chara;//0*
22. intb;//2345
23. shortc;//67
24. };
25. #pragmapack()
27. #pragmapack(1)
28. structD
29. {
30. chara;//0
31. intb;//1234
32. shortc;//56
33. };
34. #pragmapack()
36. intmain()
37. {
38. cout<<"sizeof(A)="<<sizeof(A)<<endl;
39. cout<<"sizeof(B)="<<sizeof(B)<<endl;
40. cout<<"sizeof(C)="<<sizeof(C)<<endl;
41. cout<<"sizeof(D)="<<sizeof(D)<<endl;
43. return0;
44. }

#include<iostream> using namespace std; struct A { int a; //0 1 2 3 char b; //4 * short c; //6 7 }; struct B { char a; //0 * * * int b; //4 5 6 7 short c; //8 9 * * }; #pragma pack(2) struct C { char a; //0 * int b; //2 3 4 5 short c; //6 7 }; #pragma pack() #pragma pack(1) struct D { char a; //0 int b; //1 2 3 4 short c; //5 6 }; #pragma pack() int main() { cout<<"sizeof(A) = "<<sizeof(A)<<endl; cout<<"sizeof(B) = "<<sizeof(B)<<endl; cout<<"sizeof(C) = "<<sizeof(C)<<endl; cout<<"sizeof(D) = "<<sizeof(D)<<endl; return 0; }

view plain copy to clipboard print ?

1. sizeof(A)=8
2. sizeof(B)=12
3. sizeof(C)=8
4. sizeof(D)=7
5. Pressanykeytocontinue

sizeof(A) = 8 sizeof(B) = 12 sizeof(C) = 8 sizeof(D) = 7 Press any key to continue

注意下面我对#pragma pack() 用法的理解，他不仅对每个成员的起始地址起作用，对整个的也起作用。请看下面的测试程序

view plain copy to clipboard print ?

1. #include<iostream>
2. usingnamespacestd;
4. #pragmapack(4)
5. structAA
6. {
7. chara;//0*******
8. doubleb;//4567891011
9. intc;//1213**
10. };//16
11. #pragmapack()
13. #pragmapack(2)
14. structAAA
15. {
16. chara;//0*
17. doubleb;//23456789起始地址也只要是2的倍数，不是8的倍数
18. intc;//1011**
19. };//14只要保证是2的倍数，不是最大double的8的倍数
20. #pragmapack()
22. intmain()
23. {
24. cout<<"sizeof(AA)="<<sizeof(AA)<<endl;
25. cout<<"sizeof(AAA)="<<sizeof(AAA)<<endl;
26. return0;
27. }

#include<iostream> using namespace std; #pragma pack(4) struct AA { char a; // 0 * * * * * * * double b; //4 5 6 7 8 9 10 11 int c; //12 13 * * };//16 #pragma pack() #pragma pack(2) struct AAA { char a; // 0 * double b; //2 3 4 5 6 7 8 9 起始地址也只要是2的倍数，不是8的倍数 int c; //10 11 * * };//14 只要保证是2的倍数，不是最大double的8的倍数 #pragma pack() int main() { cout<<"sizeof(AA) = "<<sizeof(AA)<<endl; cout<<"sizeof(AAA) = "<<sizeof(AAA)<<endl; return 0; }

view plain copy to clipboard print ?

1. sizeof(A)=24
2. sizeof(AA)=40
3. sizeof(A2)=20
4. sizeof(AA2)=28
5. Pressanykeytocontinue

sizeof(A) = 24 sizeof(AA) = 40 sizeof(A2) = 20 sizeof(AA2) = 28 Press any key to continue

下面接受有结构体嵌套的时候：

对于整个结构体作为成员函数时，他的起始地址不是以该结构体整体作为标准，而是以其内的成员为标准

view plain copy to clipboard print ?

1. #include<iostream>
2. usingnamespacestd;
4. structA
5. {
6. inta;//0123
7. charb;//4***
8. doublec;//89101112131415
9. shortd;//1617******
10. };//24
12. structAA
13. {
14. chara;//0*******
15. Ab;//8..31
16. intc;//32333435****
17. };
19. #pragmapack(4)
20. structA2
21. {
22. inta;//0123
23. charb;//4***
24. doublec;//89101112131415
25. shortd;//1617**
26. };//20
27. #pragmapack()
29. structAA2
30. {
31. chara;//0***
32. A2b;//4..23
33. intc;//24252627
34. };
38. intmain()
39. {
41. cout<<"sizeof(A)="<<sizeof(A)<<endl;
42. cout<<"sizeof(AA)="<<sizeof(AA)<<endl;
43. cout<<"sizeof(A2)="<<sizeof(A2)<<endl;
44. cout<<"sizeof(AA2)="<<sizeof(AA2)<<endl;
45. return0;
46. }

#include<iostream> using namespace std; struct A { int a; //0 1 2 3 char b; //4 * * * double c; //8 9 10 11 12 13 14 15 short d; //16 17 * * * * * * };//24 struct AA { char a; //0 * * * * * * * A b; //8 .. 31 int c; //32 33 34 35 * * * * }; #pragma pack(4) struct A2 { int a; //0 1 2 3 char b; //4 * * * double c; //8 9 10 11 12 13 14 15 short d; //16 17 * * };//20 #pragma pack() struct AA2 { char a; //0 * * * A2 b; //4 .. 23 int c; //24 25 26 27 }; int main() { cout<<"sizeof(A) = "<<sizeof(A)<<endl; cout<<"sizeof(AA) = "<<sizeof(AA)<<endl; cout<<"sizeof(A2) = "<<sizeof(A2)<<endl; cout<<"sizeof(AA2) = "<<sizeof(AA2)<<endl; return 0; }

view plain copy to clipboard print ?

1. sizeof(A)=24
2. sizeof(AA)=16
3. sizeof(AAA)=14
4. Pressanykeytocontinue

sizeof(A) = 24 sizeof(AA) = 16 sizeof(AAA) = 14 Press any key to continue

最后注意：static成员和函数其实是类层次的，不在对象中分配空间，而成员函数其实是被编译为全局函数了，所以也不在对象中。

view plain copy to clipboard print ?

1. #include<iostream>
2. usingnamespacestd;
4. structempty{};//1
5. structconstAndStatic
6. {
7. constinti;//0123****
8. constdoubled;//89101112131415
9. staticcharc;
10. staticvoidTestStatic(){}
11. voidTestNoStatic(){}
12. };//16
14. intmain()
15. {
17. cout<<"sizeof(empty)="<<sizeof(empty)<<endl;
18. cout<<"sizeof(constAndStatic)="<<sizeof(constAndStatic)<<endl;
20. return0;
21. }

#include<iostream> using namespace std; struct empty{}; // 1 struct constAndStatic { const int i; //0 1 2 3 * * * * const double d; //8 9 10 11 12 13 14 15 static char c; static void TestStatic(){} void TestNoStatic(){} }; // 16 int main() { cout<<"sizeof(empty) = "<<sizeof(empty)<<endl; cout<<"sizeof(constAndStatic) = "<<sizeof(constAndStatic)<<endl; return 0; }

view plain copy to clipboard print ?

1. sizeof(empty)=1
2. sizeof(constAndStatic)=16
3. Pressanykeytocontinue