[面试经]字节对齐

一、快速理解

  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

时间： 2024-12-31 18:00:11

[面试经]字节对齐的相关文章

浅谈VC中的字节对齐

原文地址:浅谈VC中的字节对齐 前几天时,在公司和同事说到了字节对齐,一直对这个概念比较模糊,只是在<程序员面试宝典>中看到过简单的描述和一些面试题.后来在论坛中有看到有朋友在询问字节对齐的相关问题,自己也答不上来,觉得应该研究一下,所以就有了这一篇博文,是对学习的一个总结,也是对成长轨迹的一个记录.       字节对齐,又叫内存对齐,个人理解就是一种C++中的类型在内存中空间分配策略.每一种类型存储的起始地址,都要求是一个对齐模数(alignment modulus)的整数倍.问题来了,为

C语言字节对齐详解

一.什么是对齐,以及为什么要对齐: 1. 现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定变量的时候经常在特定的内存地址访问,这就需要各类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐. 2. 对齐的作用和原因:各个硬件平台对存储空间的处理上有很大的不同.一些平台对某些特定类型的数据只能从某些特定地址开始存取.其他平台可能没有这种情况,但是最常见的是如果不按照适合其平台的要求对数据存放进行对齐,

C++字节对齐容易被忽略的两个问题

今天我就和大家分享一下C++字节对齐容易被忽略的两个问题.以下问题也是我实际开发工作中遇到的,如果有不同意见欢迎交流   在这里就分享两条开发中曾经忽略的问题:1.Union(联合体)的字节对齐先看代码:#pragma pack(4) struct com {  union  {   double dTest;   int nTest;   char szTest[14];  };  char chTest1;  char chTest2; }; #pragma pack() sizeof(st

cpu-c语言中字节对齐求解？？

问题描述 c语言中字节对齐求解?? 在其中一篇文章中看到这样一段话:比如在32位cpu下,假设一个整型变量的地址为0x00000004,那它就是自然对齐的.假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002-0x00000003的一个short,第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据,如果变量在0x00000003地址上的话则要访问三次内存,第一次为char,

结构体struct、枚举enum、联合体union、位字段、自定义类型typedef、字节对齐

结构体struct 1 结构体的基本知识 2 结构体与函数 3 结构体数组 4 自引用结构体 枚举变量enum 联合体union 位字段 1 一般的方法定义屏蔽吗 2 用位字段来定义屏蔽吗 自定义类型typedef 字节对齐 pragma pachx 按x个字节对齐 1.结构体struct 1.1 结构体的基本知识 #include <stdio.h> struct point{ int x; int y; }p1, p2, p3; struct point pt; struct point

字节对齐（强制对齐以及自然对齐）

struct {}node; 32为的x86,window下VC下sizeof(node)的值为1,而linux的gcc下值为0: 一.WINDOWS下(VC--其实GCC和其原理基本一样,象这种问题,一般要查具体的编译器设置)字节对齐的规则: 1.一般设置的对齐方式为1,2,4字节对齐方式,VC一般默认为4字节(最大为8字节).结构的首地址必须是结构内最宽类型的整数倍地址:另外,结构体的每一个成员起始地址必须是自身类型大小的整数倍(需要特别注意的是windows下是这样的,但在linux的gc

c++内存中字节对齐问题详解

一.什么是字节对齐,为什么要对齐?    现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐.    对齐的作用和原因:各个硬件平台对存储空间的处理上有很大的不同.一些平台对某些特定类型的数据只能从某些特定地址开始存取.比如有些架构的CPU在访问 一个没有进行对齐的变量的时候会发生错误,那么在这种

cocos2d-x-xcode下cocos2dx工程字节对齐问题

问题描述 xcode下cocos2dx工程字节对齐问题 最近小的将android下的cocos2dx工程移入苹果中时,发现在xcode中存在字节对齐问题: 例,有结构体如下: struct tagTest { unsigned char cFst; unsigned char cSec; unsigned char cThird[2]; long long iFour; }; 问题如下: 1.在xcode中用sizeof(struct tagTest)求得的大小为12.(问题1:是否哪里有什么默

C/C++结构体字节对齐详解

原文:http://blog.csdn.net/hyljqr/article/details/500899 结构体的sizeof先看一个结构体:struct S1{    char c;    int i;};  sizeof(s1)在VC6中按默认设置得到的结果为8.我们先看看sizeof的定义--sizeof的结果等于对象或者类型所占的内存字节数,好吧,那就让我们来看看S1的内存分配情况S1 s1 = { 'a', 0xFFFFFFFF };定义上面的变量后,加上断点,运行程序,观察s1所在