`
SunnyYoona
  • 浏览: 361592 次
社区版块
存档分类
最新评论

[面试经]字节对齐

 
阅读更多

一、快速理解

  1. 什么是字节对齐?
    在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。在结构中,编译器为结构的每个成员按其自然边界(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。
    为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”. 比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.
  2. 字节对齐有什么作用?
    字节对齐的作用不仅是便于cpu快速访问,同时合理的利用字节对齐可以有效地节省存储空间。
    对于32位机来说,4字节对齐能够使cpu访问速度提高,比如说一个long类型的变量,如果跨越了4字节边界存储,那么cpu要读取两次,这样效率就低了。但是在32位机中使用1字节或者2字节对齐,反而会使变量访问速度降低。所以这要考虑处理器类型,另外还得考虑编译器的类型。在vc中默认是4字节对齐的,GNU gcc 也是默认4字节对齐。
  3. 更改C编译器的缺省字节对齐方式
    在缺省情况下,C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地,可以通过下面的方法来改变缺省的对界条件:

    使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。
    使用伪指令#pragma pack (),取消自定义字节对齐方式。
    
    __attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。
    __attribute__ ((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。
    
  4. 举例说明

三 编译器是按照什么样的原则进行对齐的?

先让我们看四个重要的基本概念:

  1. 数据类型自身的对齐值:
    对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,单位字节。
  2. 结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
  3. 指定对齐值:#pragma pack (value)时的指定对齐值value。
  4. 数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中小的那个值。

有了这些值,我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值。有效对齐N,就是表示“对齐在N上”,也就是说该数据的”存放起始地址%N=0”。而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放,结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍)。

四 案例分析

struct B{
    char b;
    int a;
    short c;
};

sizeof(B) = 12

假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。

第一个成员变量b的自身对齐值是1,比指定或者默认指定对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0。

第二个成员变量a,其自身对齐值为4,所以有效对齐值也为4,所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,符合0x0004%4=0,且紧靠第一个变量。

第三个变量c,自身对齐值为2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。

再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求,0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了,因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍。其实诸如:对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了。

2.案例2

#pragma pack (2)
struct C{
    char b;
    int a;
    short c;
};
#pragma pack ()

sizeof(C) = 8

第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1=0;
第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续字节中,符合0x0002%2=0。
第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放在0x0006、0x0007中,符0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8。

#include<iostream>
using namespace std;

// 默认对齐方式 4
struct A {
    int a;
    char b;
    short c;
};

struct B {
    char b;
    int a;
    short c;
};

// 指定按2字节对齐
#pragma pack (2)
struct C {
    char b;
    int a;
    short c;
};
// 取消指定对齐,恢复缺省对齐
#pragma pack ()


// 指定按1字节对齐
#pragma pack (1)
struct D {
    char b;
    int a;
    short c;
};
//取消指定对齐,恢复缺省对齐
#pragma pack ()

int main(){
    int *a;
    cout<<"sizeof(指针)->"<<sizeof(a)<<endl;
    cout<<"sizeof(int)->"<<sizeof(int)<<endl;
    cout<<"sizeof(short)->"<<sizeof(short)<<endl;
    cout<<"sizeof(char)->"<<sizeof(char)<<endl;
    cout<<"sizeof(double)->"<<sizeof(double)<<endl;
    cout<<"sizeof(float)->"<<sizeof(float)<<endl;

    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;
}

(64位)
这里写图片描述

A内存布局

这里写图片描述

B内存布局

这里写图片描述

C内存布局

这里写图片描述

D内存布局

这里写图片描述

#include<iostream>
using namespace std;

// 结构体的自身对齐值(4)
#pragma pack (4)
struct S{
    int id;
    double height;
    float weight;
};
#pragma pack ()

// 结构体的自身对齐值:其成员中自身对齐值最大值(8)
/*
    默认情况:24
    int [0] - [3]
    double [8] - [15]
    float [16] - [19]
*/
struct Student{
    int id;
    double height;
    float weight;
};
/*
    默认情况:48
    char [0] - [1]
    int [4] - [7]
    double [8] - [15]
    short [16] - [17]
    Student [24] - [47]
*/
struct StudentInfo{
    char name[2];
    int id;
    double socore;
    short grade;
    Student stu;
};



int main(){
    cout<<"sizeof(S)->"<<sizeof(S)<<endl;
    cout<<"sizeof(Student)->"<<sizeof(Student)<<endl;
    cout<<"sizeof(StudentInfo)->"<<sizeof(StudentInfo)<<endl;
    return 0;
}

S内存布局 sizeof(S) = 16

这里写图片描述

Student内存布局 sizeof(Student) = 24

这里写图片描述

StudentInfo内存布局 sizeof(StudentInfo) = 48

这里写图片描述

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

//#pragma pack(1)  /* n = 1, 2, 4, 8, 16 */  

/* 
    默认情况:24 
    int [0] - [3] 
    double [8] - [15]  
    float [16] - [19] 
*/  
typedef struct bb  
{  
    int id;  
    double weight;  
    float height;  
}BB;  
/* 
    默认情况:48 
    char [0] - [1] 
    int [4] - [7] 
    double [8] - [15] 
    short [16] - [17] 
    BB [24] - [47] 
*/  
typedef struct aa  
{  
    char name[2];  
    int  id;      
    double score;      
    short grade;          
    BB b;  
}AA;  

/* 
    默认情况:12 
*/  
typedef struct cc  
{  
    char x1;  
    short x2;  
    float x3;  
    char x4;  
}CC;  
/*默认情况:8 
  int   [0] - [3] 
  char  [4] 
  short [6] - [7]    

  [0][1][2][3] 
  [4][5][6][7] 
  char 补充一个字节占据两个字节  short 占据两个字节 

  #pragma pack(2)  8 

  int   [0] - [3] 
  char  [4] 
  short [6] - [7] 
  [0][1] 
  [2][3] 
  [4][5] 
  [6][7] 

  #pragma pack(1)  7 

  int   [0] - [3] 
  char  [4] 
  short [5] - [6] 
  [0] 
  [1] 
  [2] 
  [3] 
  [4] 
  [5] 
  [6] 
*/  
typedef struct dd  
{  
    int x1;   
    char x2;  
    short x3;  
}DD;  
/*默认情况:12 
    char  [0] 
    int   [4] - [7]  
    short [8] - [9] 
    [0][1][2][3] 
    [4][5][6][7] 
    [8][9][10][11] 

    #pragma pack(2)  8 

    char  [0] 
    int   [2] - [5] 
    short [6] - [7] 
    [0][1] 
    [2][3] 
    [4][5] 
    [6][7] 

    #pragma pack(1)  7 

    char  [0] 
    int   [1] - [4] 
    short [5] - [6] 
    [0] 
    [1] 
    [2] 
    [3] 
    [4] 
    [5] 
    [6] 
*/  
typedef struct ee  
{  
    char x1;  
    int x2;  
    short x3;  
}EE;  


int main()  
{  
    printf("int:%d char:%d short:%d double:%d float:%d\n",sizeof(int),sizeof(char),sizeof(short),sizeof(double),sizeof(float));  
    printf("sizeof(AA):%d\n",sizeof(AA));  
    printf("sizeof(BB):%d\n",sizeof(BB));  
    printf("sizeof(CC):%d\n",sizeof(CC));  
    printf("sizeof(DD):%d\n",sizeof(DD));  
    printf("sizeof(EE):%d\n",sizeof(EE));  
    return 0;  
}  

例题:若是在32bit机器上,使用gcc编译器,得到的sizeof(A)和sizeof(B)分别为多少?

class A
{
    int a;
    short b;
    int c;
    char d;
};
class B
{
    double a;
    short b;
    int c;
    char d;
};

网友解析:

第一个我个人的理解的对齐 要满足2点
(1) 每个元素的起始位置要能被其大小(字节数)整除
(2) 总体大小要能被最大的元素大小整除
那么第一个
int a :[0..3]
short b :[4..5]
int c 起点要能被4整除 所以是[8..11]
char d [12..13]
一共[0..14]是15个byte
总体要设置为最大(int) 4的倍数 所以应该占16 byte

第二个
double a : [0..7]
short b : [8..9]
int c 起点要能被4整除[12..15]
char d [16,17]

一个 [0..17]是18个byte
总体要设置为最大(double) 8的倍数, 所以应该占24 byte

例题:在x86 32架构编译中,预设的结构成员对齐编译选项为8字节,计算sizeof(Foo)

struct Foo{
    float f;
    char c;
    int32_t i;
}

结构体Foo的自身对齐值为数据成员最大的自身对齐值int32_t的值为4。
有效对齐值为自身对齐值和预设对齐值的较小值即8和4的较小者为4。

这里写图片描述

综述:sizeof(Foo) = 12

<script type="text/javascript"> $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('<ul/>').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($('<li/>').text(i)); }; $numbering.fadeIn(1700); }); }); </script>
分享到:
评论

相关推荐

    字节对齐与结构体大小

    结构体的sizeof值,并不是简单的将其中各元素所占字节相加,而是要考虑到存储空间的字节对齐问题。这些问题在平时编程的时候也确实不怎么用到,但在一些笔试面试题目中出是常常出现,对sizeof我们将在另一篇文章中...

    华为公司 java 面试题.mht

    华为公司 java 面试题.mht

    C&C++面试笔试题透析(笔试和面试中遇到)

    什么是字节对齐,为什么要对齐? 字节对齐对程序的影响? 编译器是按照什么样的原则进行对齐的? 如何修改编译器的默认对齐值? 线程同步的三种方式? 函数重载和函数覆盖的区别? ...... 以及程序示例

    C语言/C++常见笔试面试题难疑点汇总

    用来改变编译器的字节对齐方式。 #pragma code_seg。它能够设置程序中的函数在obj文件中所在的代码段。如果未指定参数,函数将放置在默认代码段.text中 #pragma once。保证所在文件只会被包含一次,它是基于磁盘文件...

    c++ 面试题 总结

    C++面试题 1.是不是一个父类写了一个virtual 函数,如果子类覆盖它的函数不加virtual ,也能实现多态? virtual修饰符会被隐形继承的。 private 也被集成,只事派生类没有访问权限而已 virtual可加可不加 子类的...

    2024年Java高工面试题 2024年Java高工面试题 2024年Java高工面试题

    对象组成:对象头(Mark Word、KlassPointer类型指针、数组长度)、实例数据、对齐填充(8个字节)CMS:初始标记、并发标记、重新标记、并发清理、并发重置 G1:初始标记、并发标记、最终标记、筛选回收1、spring是...

    百度地图毕业设计源码-Interview-Experience:面试经历

    7、为什么要字节对齐 8、虚函数会增加类的大小吗 9、图形学了解吗 10、stable_sort和sort区别 11、异常安全讲一下(查一下) 12、手写strncpy 13、两个矩形怎么判断重叠 360 视频一面 1、自我介绍 2、Linux系统了解...

    C 语言深度解剖--解开程序员面试笔试的秘密

    第一章 关键 字............................................................................................. ...................................... 9 1.1,最宽恒大量的关键字----auto......................

    怎么刷leetcode-interviewPrep:面试准备

    三字节采访 破冰船 那个人问我是否在某个时候搬到湾区,或者我是否在那里出生和长大。 我是多么喜欢住在湾区。 他分享了他在格鲁吉亚(俄罗斯)的生活经历。 我想我们花了大约 5 分钟的时间谈论 SF 湾的利弊。 他说...

    C学习深入学习总结

    10.2 你知道字节对齐对结构体占用内存空间大小的影响吗?如何计算结构体占用内存的小? 17 11 宏 19 11.1 你知道宏的本质是什么吗?函数?语句?类型定义?或者其他? 19 11.2 你知道语言设计者为什么设计宏吗?这些...

    C语言深度解剖_word版

    C语言深度解剖 word版 解开程序员面试笔试的秘密第一章关键字......................................................................................................................9 1.1,最宽恒大量的关键字...

Global site tag (gtag.js) - Google Analytics