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

最新推荐文章于 2024-10-01 22:19:10 发布
最新推荐文章于 2024-10-01 22:19:10 发布
阅读量365 收藏 2
点赞数 2
文章标签： 面试 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cat_fish_rain/article/details/133279567
版权

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：

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(1)
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量提升到2的 倍数6，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

int main()
{
    cout << sizeof(AA) << endl;
    system("pause");
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(2)
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

struct BB
{

    // BB 是注释掉以上 内容 按照2个字节对齐的情况
    int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。

    //整体存放【0-8】 位置中，共9个字节。
};

int main()
{

    // cout << sizeof(AA) << endl;
    cout << sizeof(BB) << endl;
    system("pause");
    return 0;
}

  

 

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(4)
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

struct BB
{

    // BB 是注释掉以上 内容 按照2个字节对齐的情况
    int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。

    //整体存放【0-8】 位置中，共9个字节。
};

struct CC
{

    int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
};

int main()
{

    // cout << sizeof(AA) << endl;
    // cout << sizeof(BB) << endl;
    cout << sizeof(CC) << endl;
    system("pause");
    return 0;
}

 

8字节对齐

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(8)
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

struct BB
{

    // BB 是注释掉以上 内容 按照2个字节对齐的情况
    int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。

    //整体存放【0-8】 位置中，共9个字节。
};

struct CC
{

    int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
};

struct DD
{

    int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
};

int main()
{

    // cout << sizeof(AA) << endl;
    // cout << sizeof(BB) << endl;
    // cout << sizeof(CC) << endl;
    cout << sizeof(DD) << endl;
    system("pause");
    return 0;
}

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

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(8)
#include <stddef.h>
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

struct BB
{

    // BB 是注释掉以上 内容 按照2个字节对齐的情况
    int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。

    //整体存放【0-8】 位置中，共9个字节。
};

struct CC
{
    int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
};

struct DD
{

    int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
};

struct EE
{

    int a;    // 4<8  按4对齐， 偏移：0 位置 {0,3}
    double b; // 8==8 按8对齐 偏移量偏移到8的倍数 偏移8 位置：{8,16}
    short c;  // 2<8 按照2 对齐 偏移 16  位置 {16,17}
    char d;   // 1<8  按照1 对齐 偏移为17 位置[18] 总大小为9
};

int main()
{

    // cout << sizeof(AA) << endl;
    // cout << sizeof(BB) << endl;
    // cout << sizeof(CC) << endl;
    // cout << sizeof(DD) << endl;
    cout << sizeof(EE) << endl;
    cout << offsetof(EE, b) << endl; //查看偏移了多少内存。
    system("pause");
    return 0;
}

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

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(8)
#include <stddef.h>
using namespace std;

struct AA
{

    int a;   //长度4>1 按照1对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度1==1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2>1,按1对齐，偏移量，存放位置区间[5,6]
    char d;  //长度1==1，按1 对齐，偏移量为6，存放位置区间[7]

    //整体存放【0-7】 位置中，共八个字节。
};

struct BB
{

    // BB 是注释掉以上 内容 按照2个字节对齐的情况
    int a;   //长度4>2 按照2对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度2>1 按1 对齐，偏移量为4，存放位置区间[4]
    short c; //长度2=1,按2对齐，整体偏移到2的倍数6，存放位置区间[6,7]
    char d;  //长度2>1，按1对齐，偏移量为7，存放位置区间[8],共9个字节。

    //整体存放【0-8】 位置中，共9个字节。
};

struct CC
{
    int a;   //长度4=4 按照4对齐，偏移量为0，存放位置区间[0,3]
    char b;  //长度4>1 按照1对齐，偏移量为4，存放区间[4]
    short c; //长度 2<4 按照两个字节对齐，对齐到2的倍数6 存放位置{6,7}
    char d;  // 1<4 ，按照1 对齐。偏移量为7.存放位置的区间为[8],总大小为9
};

struct DD
{

    int a;   // 4<8  按4对齐， 偏移：0 位置 {0,3}
    char b;  // 1<8 按1对齐 偏移：4 位置：{4}
    short c; // 2<8 按照2 对齐 偏移 6  位置 {6,7}
    char d;  // 1<8  按照1 对齐 偏移为7 位置[8] 总大小为9
};

struct EE
{

    int a;    // 4<8  按4对齐， 偏移：0 位置 {0,3}
    double b; // 8==8 按8对齐 偏移量偏移到8的倍数 偏移8 位置：{8,16}
    short c;  // 2<8 按照2 对齐 偏移 16  位置 {16,17}
    char d;   // 1<8  按照1 对齐 偏移为17 位置[18] 总大小为9
};

//=============================================================
struct GG
{

    //结构体内部最大元素为int.由于偏移量8刚好是4 的倍数，所以从8 开始存放struct 对应了规则三。
    int a1;   // 4<8   4  8   [8,11]
    char b1;  // 1<8  1  12  [12]
    short c1; // 2<8   2  14  [14,15]
    char d1;  // 1 <8   1  16  [16]
};
struct FF
{

    int a;   // 4<8 按4   偏移0 存放的位置【0,3】
    char b;  // 1<8 按1   偏移4           [4]
    short c; // 2<8  2      6            [6,7]

    GG g;

    //子strcut整体对齐系数=min((max(int,short,char),8))=4. 将内存补齐到4 的整数倍 20.

    char d; // 1<8  1   21  21

    //整体对齐系数 4 所有有21 补到24.
};
//===========================================
int main()
{

    // cout << sizeof(AA) << endl;
    // cout << sizeof(BB) << endl;
    // cout << sizeof(CC) << endl;
    // cout << sizeof(DD) << endl;
    // cout << sizeof(EE) << endl;
    // cout << offsetof(EE, b) << endl; //查看偏移了多少内存。

    cout << sizeof(FF) << endl;
    // cout << offsetof(FF, GG) << endl;

    system("pause");
    return 0;
}

 

 

 4.练习：

        

#include <iostream>
#include <vector>
#include <algorithm>
#pragma pack(8)
using namespace std;

struct A
{

    int a; // [0,4]
    double b;
    // [ 8, 16 ]
    float c;
    // [ 17, 20 ]
};
// #24

struct B
{

    char e[2]; // 1<8 按照2对齐  偏移 0  位置【0,1】
    short h;   // 2<8 2             2       [2,4]

    A a; // 24

    // 一共28 偏移一起达到32.
};

int main()
{
    cout << sizeof(B) << endl;
    system("pause");
    return 0;
}

 

 

cat_fish_rain
关注
找工作笔试面试补充基础知识(1)---内存对齐
寒小阳
09-12 6160
之前分析迅雷近几年笔试题的时候，提到了一类问题考察的是内存对齐的知识。之前做的总结中少了这部分知识，而回忆起来，去年的大大小小那么多场笔试，确实有不少公司都还考察这个，这里正好就单独写一篇，总结总结这个问题吧。有不当之处，欢迎大家留言指正，谢谢！ 一．何为字节对齐，字节对齐的作用         我们现在使用的算机中内存空间都是按照字节（Byte）划分的，理论上说，似乎对任何类型的变量
为什么要内存对齐
土豆的博客
07-22 8551
当我们听到”内存对齐“这个概念时，从字面意思来看，很容易理解。那就是让内存对齐。        当然  就会有人说  你这不是废话 ？？         现在我就来说一说为什么要内存对齐以及怎么个对齐法（如何对齐）？        首先来谈谈什么叫内存对齐！！我百度了一下如下解释： 内存对齐：       内存对齐”应该是编译器的“管辖范围”。编译器为程序中的每个“数据单元”安排在适当的
关于内存对齐的面试题
weixin_30472035的博客
02-25 179
郑重声明：本文是笔者根据个人理解所写，错误难免，欢迎拍砖！ 　　　　 可以任意转载、修改，转载时是否标明出处，随君而定！ 请说出如下2种方式，哪种更好，为什么？ 方式一： void foo(int a, float b, char* ch, double d, float f); 方式二： struct A { int a; float b; ...
内存对齐的原理和使用
最新发布
喜欢就关注吧
10-01 1304
从内存对齐的原理到控制使用
c++面试问答：内存对齐
实践出真理
02-11 321
所谓的内存对齐，就是为了让内存存取更加有效率而采取的一种优化手段，对齐的结果是使得内存中数据的首地址是CPU单次获取数据大小的整数倍。比如，CPU单次获取数据的大小是4个字节，对于 int x 而言，如果 x 的地址是0x00000000、0x00000004...等4的倍数，就是内存对齐。此外，这里说的内存对齐，一般就是针对结构体来进行探讨的，所以这就可以理解在本文后面提到的对整体和成员有不同的对齐方式了。
有趣的内存对齐面试题
Gerald的博客
05-11 476
有趣的内存对齐面试题 题目描述： 内存对齐机制是一个用空间换取时间的做法，具体怎么做的，或者为什么要这么做？可以参考我的博客：内存对齐 这道题是这样的：问程序会在那么地方崩溃？ 如果你直接答：那么你就错了兄弟。这道题是分平台的。我们先在Linux CentOS X86_64位平台下运行一下试试看。 #include <iostream> struct S { int a; ...
linux bsp笔试题,Linux BSP工程师面试常问问题汇集.pdf
weixin_32407987的博客
05-25 1711
Linux BSP工程师面试常问问题汇集Linux BSP 工程师面试常问问题汇集TD1．本文章遵从” 署名-非商业性使用 3.0 中国大陆 (CC BY-NC 3.0 CN)”2. 转载或引用本文档中的内容须注明 “资料来源：HB@ Technical Document” 字样Change HistoryVersion Date Editor Com...
2024-JAVA-大数据-面试汇总_大数据java部门面试(1)
2401_84141419的博客
04-27 741
1,sex 改为age,非空，默认值为02 统计035号课程分数大于036号课程分数的学生ID3 统计所有003班学生各门功课的课程名称和平均分以上是所有的面试题，在写sql的时候，卡了好久，因为好久没写过三表联查，子查询的sql，差不多忘了，后来下线时，一度以为自己挂了，但是过了一个多小时之后，看了一下状态，面试一轮通过，可能是面试官看我前面的问题答得还可以让我过吧。只是这问题量着实有点多。希望尽快约下轮面试。
嵌入式笔试面试题目系列（汇总）
热门推荐
高空的博客
02-28 8万+
本系列按类别对题目进行分类整理，这样有利于大家对嵌入式的笔试面试考察框架有一个完整的理解。
2024-JAVA-大数据-面试汇总_大数据java部门面试(2)
2401_84141419的博客
04-27 746
RDD就是弹性分布式数据集，可以理解为一种数据结构，拥有多种不同的RDD算子。
数字验证面试笔试
weixin_61103637的博客
04-14 916
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
C++面试题之结构体内存对齐计算问题总结大全
08-29
主要给大家总结了关于C++面试题中结构体内存对齐计算问题的相关资料，文中通过示例代码介绍的非常详细，通过这些介绍的内容对大家在面试C++工作的时候，会有一定的参考帮助，需要的朋友们下面随着小编来一起学习学习吧。
C/C++ 内存对齐题目练习
wwxy1995的博客
04-07 820
结构体/类内存对齐的规则 1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除； 备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能被该基本数据类型所整除的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。 2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上...
内存对齐相关面试题
mxrrr_sunshine的博客
01-14 688
题目一#pragma pack (4) unsigned short* pucchararray[10][10]; typedef union unRec { unsigned long L1; unsigned short S2[7]; unsigned char C3; }REC_S; REC_S stmax, *pstmax; int main() { prin
C++面试题(一)-C++结构体内存对齐
rl小透明
06-03 420
结构体内存对⻬⽅式和为什么要进⾏内存对⻬？
C++常见面试问题之内存对齐
weixin_57672347的博客
10-23 361
2.如果数据是从1字节开始的，就首先要将前 4 个字节读取到寄存器，并再次读取 4-7 个字节数据进入寄存器，接着把0字节，5，6，7字节的数据剔除，最后合并 1，2，3，4 字节的数据进入寄存器，所以说，当内存没有对齐时，寄存器进行了很多额外的操作，现代计算机中内存空间都是按照 byte 划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但是实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k（通常它为4或8）的倍数，这就是所谓的内存对齐。
《C语言深度剖析》学习笔记----内存管理（1）----内存对齐
CoderChe
08-01 3294
最近看了好多，也编了好多C语言的浩强哥书后的题，总觉的很不爽，真的真的好怀念linux驱动的代码，好怀念那下划线，那结构体，虽然自己还很菜。 同时看了一遍陈正冲老师的C语言深度剖析，收益很多，又把唐老师的视频复习了一部分，感觉收获更多。 这阶段一直想写一篇博客，其实有好多东西，先写一下C语言中的内存对齐吧。   大家都知道，在C语言中定义一个变量，char是占用一个字节的，int占用四个字
面试中问到内存对齐该怎么回答？
Xiao_qsn的博客
11-21 602
在面试中，阿里面试还有天融信面试中会问到内存对齐，我贴出了关于我的回答 1.问到：你说说你理解的内存对齐？ 可以针对于两个方面来说，什么是内存对齐？为什么要内存对齐？来解释 1.什么是内存对齐？ 内存对齐是编译器将程序中的每个“数据单元”安排在合适的位置上。 2.为什么要内存对齐？ 我们知道内存是以字节为单位存储的，但是处理器存取内存是以块为单位，块的大小是2,4,8,16字节大小，这是内存的存取粒度 从内存存取效率方面，内存对齐可以提升...
C++内存对齐
C_Dreams的博客
10-08 286
转载自：http://www.cnblogs.com/xylc/p/3780907.html 一，什么是内存对齐？内存对齐用来做什么？ 所谓内存对齐，是为了让内存存取更有效率而采用的一种编译阶段优化内存存取的手段。 比如对于int x;（这里假设sizeof(int)==4），因为cpu对内存的读取操作是对齐的，如果x的地址不是4的倍数，那么读取这个x，需要读取两次共8个字节，然后还要将其拼
C++面试经典问题详解：extern"C"、区分编译器与内存对齐
以上知识点涵盖了C++编程中的一些核心概念，包括语言特性、编译器标志、数据类型和内存管理，这些都是面试时常见的问题点。掌握这些内容有助于提升面试表现，并在实际开发中编写出高效、兼容的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值