• 内存对齐--面试常问问题和笔试常考问题

    1.内存对齐的意义

    C++ 内存对齐的主要意义可以简练概括为以下几点：

    1. 提高访问效率：内存对齐可以使数据在内存中以更加紧凑的方式存储，从而提高了数据的访问效率。处理器通常能够更快地访问内存中对齐的数据，而不需要额外的字节偏移计算。

    2. 硬件要求：许多硬件平台要求数据按照一定的对齐规则存储，否则可能会导致性能下降或者错误。不符合硬件要求的数据存储方式可能会引发总线错误或性能降低。

    3. 结构体和类的正确性：在C++中，结构体和类中的成员变量通常按照编译器的默认对齐方式进行排列，以确保数据的正确访问和存储。手动调整对齐方式可以保证数据的正确性。

    4. 跨平台开发：内存对齐可以确保数据在不同平台上的一致性。这对于跨平台开发非常重要，因为不同的硬件架构可能有不同的对齐要求。

    5. 节省内存：内存对齐可以减少内存碎片，从而节省内存空间。当数据按照对齐要求存储时，不会出现因为填充字节而浪费内存的情况。

    总之，C++ 内存对齐的主要意义在于提高访问效率、符合硬件要求、确保数据的正确性、支持跨平台开发以及节省内存空间。通过遵循对齐规则，可以充分利用硬件的性能优势，并确保程序在不同平台上的可移植性和正确性。

    2.对齐原则


    原则1 :数据成员对齐规则:结构(struct)(或联合(union))的数据成员，第一个数据成员放在
    offiset为0的地方,以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身
    长度中,比较小的那个进行。（先偏移到那个对齐标准数的指定倍数，在进行加上本身）
    原则2:结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后，结构(或联合)本身也要进
    行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的
    那个进行。
    原则3 :结构体作为成员:如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元
    素大小的整数倍地址开始存储。

    3.默认对齐值

    默认对齐值:
    Linux默认#pragma pack(4)
    window默认#pragma pack(8)
    注:可以通过预编译命令#pragma pack(n) , n=1,2,4,8,16来改变这一系数,其中的n就是指定
    的“对齐系数”。

    例题1：

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(1)
    5. using namespace std;
    6.  
    7. struct AA
    8. {
    9.  
    10.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    11.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    12.     short c; //长度2>1,按1对齐，偏移量提升到2的 倍数6，存放位置区间[5,6]
    13.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    14.  
    15.     //整体存放【0-7】 位置中，共八个字节。
    16. };
    17.  
    18. int main()
    19. {
    20.     cout << sizeof(AA) << endl;
    21.     system("pause");
    22.     return 0;
    23. }


    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(2)
    5. using namespace std;
    6.  
    7. struct AA
    8. {
    9.  
    10.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    11.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    12.     short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    13.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    14.  
    15.     //整体存放【0-7】 位置中，共八个字节。
    16. };
    17.  
    18. struct BB
    19. {
    20.  
    21.     // BB 是注释掉以上 内容 按照2个字节对齐的情况
    22.     int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    23.     char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    24.     short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    25.     char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。
    26.  
    27.     //整体存放【0-8】 位置中，共9个字节。
    28. };
    29.  
    30. int main()
    31. {
    32.  
    33.     // cout << sizeof(AA) << endl;
    34.     cout << sizeof(BB) << endl;
    35.     system("pause");
    36.     return 0;
    37. }

      

     

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(4)
    5. using namespace std;
    6.  
    7. struct AA
    8. {
    9.  
    10.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    11.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    12.     short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    13.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    14.  
    15.     //整体存放【0-7】 位置中，共八个字节。
    16. };
    17.  
    18. struct BB
    19. {
    20.  
    21.     // BB 是注释掉以上 内容 按照2个字节对齐的情况
    22.     int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    23.     char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    24.     short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    25.     char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。
    26.  
    27.     //整体存放【0-8】 位置中，共9个字节。
    28. };
    29.  
    30. struct CC
    31. {
    32.  
    33.     int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    34.     char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    35.     short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    36.     char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
    37. };
    38.  
    39. int main()
    40. {
    41.  
    42.     // cout << sizeof(AA) << endl;
    43.     // cout << sizeof(BB) << endl;
    44.     cout << sizeof(CC) << endl;
    45.     system("pause");
    46.     return 0;
    47. }

     

    8字节对齐

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(8)
    5. using namespace std;
    6.  
    7. struct AA
    8. {
    9.  
    10.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    11.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    12.     short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    13.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    14.  
    15.     //整体存放【0-7】 位置中，共八个字节。
    16. };
    17.  
    18. struct BB
    19. {
    20.  
    21.     // BB 是注释掉以上 内容 按照2个字节对齐的情况
    22.     int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    23.     char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    24.     short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    25.     char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。
    26.  
    27.     //整体存放【0-8】 位置中，共9个字节。
    28. };
    29.  
    30. struct CC
    31. {
    32.  
    33.     int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    34.     char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    35.     short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    36.     char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
    37. };
    38.  
    39. struct DD
    40. {
    41.  
    42.     int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    43.     char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    44.     short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    45.     char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
    46. };
    47.  
    48. int main()
    49. {
    50.  
    51.     // cout << sizeof(AA) << endl;
    52.     // cout << sizeof(BB) << endl;
    53.     // cout << sizeof(CC) << endl;
    54.     cout << sizeof(DD) << endl;
    55.     system("pause");
    56.     return 0;
    57. }

    #按照8位，有 包含 double的情况。

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(8)
    5. #include 
    6. using namespace std;
    7.  
    8. struct AA
    9. {
    10.  
    11.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    12.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    13.     short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    14.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    15.  
    16.     //整体存放【0-7】 位置中，共八个字节。
    17. };
    18.  
    19. struct BB
    20. {
    21.  
    22.     // BB 是注释掉以上 内容 按照2个字节对齐的情况
    23.     int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    24.     char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    25.     short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    26.     char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。
    27.  
    28.     //整体存放【0-8】 位置中，共9个字节。
    29. };
    30.  
    31. struct CC
    32. {
    33.     int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    34.     char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    35.     short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    36.     char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
    37. };
    38.  
    39. struct DD
    40. {
    41.  
    42.     int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    43.     char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    44.     short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    45.     char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
    46. };
    47.  
    48. struct EE
    49. {
    50.  
    51.     int a;    // 4<8  按4对齐， 偏移：0 位置 {0,3}
    52.     double b; // 8==8 按8对齐 偏移量偏移到8的倍数 偏移8 位置：{8,16}
    53.     short c;  // 2<8 按照2 对齐 偏移 16  位置 {16,17}
    54.     char d;   // 1<8  按照1 对齐 偏移为17 位置[18] 总大小为9
    55. };
    56.  
    57. int main()
    58. {
    59.  
    60.     // cout << sizeof(AA) << endl;
    61.     // cout << sizeof(BB) << endl;
    62.     // cout << sizeof(CC) << endl;
    63.     // cout << sizeof(DD) << endl;
    64.     cout << sizeof(EE) << endl;
    65.     cout << offsetof(EE, b) << endl; //查看偏移了多少内存。
    66.     system("pause");
    67.     return 0;
    68. }

     例四：结构体包含结构体的运算。

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(8)
    5. #include 
    6. using namespace std;
    7.  
    8. struct AA
    9. {
    10.  
    11.     int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    12.     char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    13.     short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    14.     char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]
    15.  
    16.     //整体存放【0-7】 位置中，共八个字节。
    17. };
    18.  
    19. struct BB
    20. {
    21.  
    22.     // BB 是注释掉以上 内容 按照2个字节对齐的情况
    23.     int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    24.     char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    25.     short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    26.     char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。
    27.  
    28.     //整体存放【0-8】 位置中，共9个字节。
    29. };
    30.  
    31. struct CC
    32. {
    33.     int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    34.     char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    35.     short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    36.     char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
    37. };
    38.  
    39. struct DD
    40. {
    41.  
    42.     int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    43.     char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    44.     short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    45.     char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
    46. };
    47.  
    48. struct EE
    49. {
    50.  
    51.     int a;    // 4<8  按4对齐， 偏移：0 位置 {0,3}
    52.     double b; // 8==8 按8对齐 偏移量偏移到8的倍数 偏移8 位置：{8,16}
    53.     short c;  // 2<8 按照2 对齐 偏移 16  位置 {16,17}
    54.     char d;   // 1<8  按照1 对齐 偏移为17 位置[18] 总大小为9
    55. };
    56.  
    57. //=============================================================
    58. struct GG
    59. {
    60.  
    61.     //结构体内部最大元素为int.由于偏移量8刚好是4 的倍数，所以从8 开始存放struct 对应了规则三。
    62.     int a1;   // 4<8   4  8   [8,11]
    63.     char b1;  // 1<8  1  12  [12]
    64.     short c1; // 2<8   2  14  [14,15]
    65.     char d1;  // 1 <8   1  16  [16]
    66. };
    67. struct FF
    68. {
    69.  
    70.     int a;   // 4<8 按4   偏移0 存放的位置【0,3】
    71.     char b;  // 1<8 按1   偏移4           [4]
    72.     short c; // 2<8  2      6            [6,7]
    73.  
    74.     GG g;
    75.  
    76.     //子strcut整体对齐系数=min((max(int,short,char),8))=4. 将内存补齐到4 的整数倍 20.
    77.  
    78.     char d; // 1<8  1   21  21
    79.  
    80.     //整体对齐系数 4 所有有21 补到24.
    81. };
    82. //===========================================
    83. int main()
    84. {
    85.  
    86.     // cout << sizeof(AA) << endl;
    87.     // cout << sizeof(BB) << endl;
    88.     // cout << sizeof(CC) << endl;
    89.     // cout << sizeof(DD) << endl;
    90.     // cout << sizeof(EE) << endl;
    91.     // cout << offsetof(EE, b) << endl; //查看偏移了多少内存。
    92.  
    93.     cout << sizeof(FF) << endl;
    94.     // cout << offsetof(FF, GG) << endl;
    95.  
    96.     system("pause");
    97.     return 0;
    98. }

     

     

     4.练习：

            

    1. #include 
    2. #include 
    3. #include 
    4. #pragma pack(8)
    5. using namespace std;
    6.  
    7. struct A
    8. {
    9.  
    10.     int a; // [0,4]
    11.     double b;
    12.     // [ 8, 16 ]
    13.     float c;
    14.     // [ 17, 20 ]
    15. };
    16. // #24
    17.  
    18. struct B
    19. {
    20.  
    21.     char e[2]; // 1<8 按照2对齐  偏移 0  位置【0,1】
    22.     short h;   // 2<8 2             2       [2,4]
    23.  
    24.     A a; // 24
    25.  
    26.     // 一共28 偏移一起达到32.
    27. };
    28.  
    29. int main()
    30. {
    31.     cout << sizeof(B) << endl;
    32.     system("pause");
    33.     return 0;
    34. }

     

     

  • 相关阅读:
    流式计算和实时计算有什么区别？
    【C++学习】智能指针
    SpringBoot集成security
    docker阅读笔记
    【OceanBase】四种不同的数据迁移方式
    Kafka 在分布式系统中的 7 大应用场景
    EF Core 配置模型
    2022 最全 Java 面试手册终于开源了，包含了 29 个知识点
    多目标应用：多目标蜣螂优化算法求解多旅行商问题（Multiple Traveling Salesman Problem, MTSP）
    Tlsr8258开发-修改蓝牙hid mouse
  • 原文地址：https://blog.csdn.net/cat_fish_rain/article/details/133279567