C语言字节对齐1 2 3 4 5

不一样系统下的C语言类型长度

Data Type	ILP32	ILP64	LP64	LLP64
char	8	8	8	8
short	16	16	16	16
int	32	64	32	32
long	32	64	64	32
long long	64	64	64	64
pointer	32	64	64	64

绝大部分64位的Unix，linux都是使用的LP64模型；32位Linux系统是ILP32模型；64位的Windows使用的是LLP64(long long and point 64)模型。html

基本概念

许多计算机系统对基本数据类型合法地址作出了一些限制，要求某种类型对象的地址必须是某个值K(一般是2，4或8)的倍数。这种对齐限制简化了造成处理器和存储器系统之间的接口的硬件设计。对齐跟数据在内存中的位置有关。若是一个变量的内存地址正好位于它长度的整数倍，他就被称作天然对齐。好比在32位cpu下，假设一个整型变量的地址为0x00000004，那它就是天然对齐的。java

为何要字节对齐

须要字节对齐的根本缘由在于CPU访问数据的效率问题。例如，假设一个处理器老是从存储器中取出8个字节，则地址必须为8的倍数。若是咱们能保证将全部的double类型数据的地址对齐成8的倍数，那么就能够用一个存储器操做来读或者写值了。不然，咱们可能须要执行两次存储器访问，由于对象可能被分放在两个8字节存储块中。linux

另外，假设一个整型变量的地址不是天然对齐，好比为0x00000002，则CPU若是取它的值的话须要访问两次内存，第一次取从0x00000002-0x00000003的一个short，第二次取从0x00000004-0x00000005的一个short而后组合获得所要的数据；若是变量在0x00000003地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，而后组合获得整型数据。而若是变量在天然对齐位置上，则只要一次就能够取出数据。ios

各个硬件平台对存储空间的处理上有很大的不一样，一些平台对某些特定类型的数据只能从某些特定地址开始存取。好比有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误，那么在这种架构下编程必须保证字节对齐。好比sparc系统，若是取未对齐的数据会发生错误，举个例：c++

char ch[8];
char *p = &ch[1];
int i = *(int *)p;

运行时会报segment error，而在x86上就不会出现错误，只是效率降低。算法

如何处理字节对齐

先让咱们看编译器是按照什么样的原则进行对齐的：shell

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

对于标准数据类型，它的地址只要是它的长度的整数倍就好了，而非标准数据类型按下面的原则对齐：
数组：按照基本数据类型对齐，第一个对齐了后面的天然也就对齐了。
联合：按其包含的长度最大的数据类型对齐。
结构体：结构体中每一个数据类型都要对齐。编程

当数据类型为结构体时，编译器可能须要在结构体字段的分配中插入间隙，以保证每一个结构元素都知足它的对齐要求。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放（对于非对齐成员须要在其前面填充一些字节，保证其在对齐位置上），结构体自己也要根据自身的有效对齐值圆整(就是结构体总长度须要是结构体有效对齐值的整数倍)，此时可能须要在结构末尾填充一些空间，以知足结构体总体的对齐—-向结构体元素中最大的元素对齐。windows

经过上面的分析，对结构体进行字节对齐，咱们须要知道四个值：centos

指定对齐值：代码中指定的对齐值，记为packLen；
默认对齐值：结构体中每一个数据成员及结构体自己都有默认对齐值，记为defaultLen；
成员偏移量：即相对于结构体起始位置的长度，记为offset；
成员长度：结构体中每一个数据成员的长度（注结构体成员为补齐以后的长度），记为memberLen。

及两个规则：

对齐规则： offset % vaildLen = 0，其中vaildLen为有效对齐值vaildLen = min(packLen, defaultLen)；
填充规则：如成员变量不遵照对齐规则，则须要对其补齐；在其前面填充一些字节保证该成员对齐。需填充的字节数记为pad

Linux和Microsoft Windows的对齐方式

一.Linux的对齐策略:

在Linux中2字节数据类型(例如short)的地址必须是2的倍数，而较大的数据类型(例如int，int *，float和double)的地址必须是4的倍数。也就是说Linux下要么2字节对齐，要么4字节对齐，没有其余格式的对齐。

二.Microsoft Windows的对齐策略:

在Windows中对齐要求更严–任何K字节基本对象的地址都必须是K的倍数，K=2，4，或者8.特别地，double或者long long类型数据的地址应该是8的倍数。能够看出Windows的对齐策略和Linux仍是不一样的。

更改C编译器的缺省字节对齐方式

在缺省状况下，C编译器为每个变量或是数据单元按其天然对界条件分配空间。通常地，能够经过下面的方法来改变缺省的对界条件：

使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。
使用伪指令#pragma pack ()，取消自定义字节对齐方式。

另外，还有以下的一种方式：

__attribute((aligned (n)))，让所做用的结构成员对齐在n字节天然边界上。若是结构中有成员的长度大于n，则按照最大成员的长度来对齐。
__attribute__ ((packed))，取消结构在编译过程当中的优化对齐，按照实际占用字节数进行对齐。

字节对齐的做用不只是便于cpu快速访问，同时合理的利用字节对齐能够有效地节省存储空间。

对于32位机来讲，4字节对齐可以使cpu访问速度提升，好比说一个long类型的变量，若是跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。可是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度下降。因此这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 也是默认4字节对齐。

何时须要设置对齐

在设计不一样CPU下的通讯协议时，或者编写硬件驱动程序时寄存器的结构这两个地方都须要按一字节对齐。即便看起来原本就天然对齐的也要使其对齐，以避免不一样的编译器生成的代码不同.

结构体举例

例子1

/************************ > File Name: struct_test.c > Author:Marvin > Created Time: Thu 22 Mar 2018 07:19:46 PM CST **********************/

#include<stdio.h>


int main()
{
    struct test {
        char a;
        short b;
        int c;
        long d;
    };
    struct test t = {'a',11,11,11};

    printf("size of struct t = %u\n", sizeof(t));

    return 0;
}

在64位centos上编译编译后结构struct test的布局以下:

因为要保证结构体每一个元素都要数据对齐，所以必须在a和b之间插入1字节的间隙使得后面的short元素2字节对齐int元素4字节对齐long元素8字节对齐，这样最终test结构大小为16字节。

运行程序结果为:

size of struct t = 16

例子2

如今考虑这样一个结构体：

struct test2 {
    int a;
    long b;
    char c;
};
struct test2 t2 = {11,11,'c'};

在64位centos上编译编译后结构struct test2的布局以下:

结构体struct test2的天然对界条件为8字节，因此须要在最后的char型数据后面再填充7个字节使得结构体总体对齐。

运行程序结构为

size of struct test2 = 24

例子3

不妨将结构体struct test2里面成员的顺序从新排列一下：

struct test3 {
    char c;
    int a;
    long b;
};
struct test3 t3 = {'c',11,11};

在64位centos上编译编译后结构struct test2的布局以下:

运行结果为：

size of struct test3 = 16

可见适当地编排结构体成员地顺序，能够在保存相同信息地状况下尽量节约内存空间。

例子4

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

假设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，这些已有类型的自身对齐值也是基于数组考虑的,只是由于这些类型的长度已知了,因此他们的自身对齐值也就已知了.
例子5

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

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

对于结构体嵌套地状况，结构体对齐算法思想：深度优先填充。

padLen = getPadLen(offset , defaultLen);
int getPadLen(int offsetLen, int defaultLen)
{
  int vaildLen = min(packLen,defaultLen);
  if(0 == vaildLen || 0 == offsetLen % vaildLen)
  {
    return 0;
  }
  return vaildLen - (offsetLen % vaildLen);
}

先对齐内层结构体：对每一个数据成员计算其defaultLen、memberLen和offset；

再遍历每一个数据成员时计算：对于基本数据类型成员defaultLen=memberLen；对于结构体成员defaultLen等于它的全部成员的最大的memberLen；遍历时对成员的memberLen进行累加，获得当前成员的offsetLen；

运用对齐及填充规则：在当前结构体成员前填充padLen个字节；

下面是结构体做为成员的例子：

struct test1 {
    int a;
    long b;
};
struct test4 {
    char a;
    struct test1 b;
    int c;
};
struct test4 t4 = {'a', {11,11},11}

test1的内存分布:

test4的内存分布:

字节对齐可能带来的隐患

代码中关于对齐的隐患，不少是隐式的。好比在强制类型转换的时候。例如：

unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;

最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，相似的操做只会影响效率，可是在MIPS或者sparc上，可能就是一个error,由于它们要求必须字节对齐.

如何查找与字节对齐方面的问题

若是出现对齐或者赋值问题首先查看

编译器的big little端设置
看这种体系自己是否支持非对齐访问
若是支持看设置了对齐与否,若是没有则看访问时须要加某些特殊的修饰来标志其特殊访问操做

举例：

#include<iostream>

using namespace std;

//windows 64 位默认 结构体对齐系数为8，32位 结构体对齐系数为4

//测试系统对齐系数
// #pragma pack(8) my_struct_1 为16字节
// #pragma pack(4) my_struct_1 为12字节
// 不加#pragma pack(8) my_struct_1 为16字节
//顾系统默认对齐系数为8

struct my_struct_1
{
    char a;     //1
    double b;   //以前补7 +8 8/8==1
};

#pragma pack(4)
struct my_struct_2
{
    char a;    //1
    double b;  //3+8
    int c;     //4 16/4=4
};
#pragma pack()

#pragma pack(2)
struct my_struct_3
{
    char a;    //1
    double b;  //1+8
    int c;     //4 14/2
};
#pragma pack()

#pragma pack(4)
struct my_struct_4
{
    char a[5];  //5
    double b;   //3+8 16/4
};
#pragma pack()

#pragma pack(2)
struct my_struct_5
{
    char a[5];  //5
    double b;   //1+8 14/2
};
#pragma pack()

#pragma pack(4)
struct my_struct_6
{
    char a;    //1
    char b[3]; //3
    char c;    //1 1+3+1
};
#pragma pack()

#pragma pack(4)
struct my_struct_7
{
    char a;    //1
    char b[3]; //3
    char c;    //1 
    int d;     //补齐 3 +4 
};
#pragma pack()

#pragma pack(4)
struct test
{
char x1;   //1
short x2;  //补齐1+ 2
float x3;  //4
char x4;   //1 补齐+3 
};
#pragma pack()

int main()
{
    cout<<"char:"<<sizeof(char)<<endl;
    cout<<"short:"<<sizeof(short)<<endl;
    cout<<"int:"<<sizeof(int)<<endl;
    cout<<"long:"<<sizeof(long)<<endl;
    cout<<"float:"<<sizeof(float)<<endl;
    cout<<"double:"<<sizeof(double)<<endl;
    cout<<"long double:"<<sizeof(long double)<<endl;

    cout<<sizeof(my_struct_1)<<endl;//8
    cout<<sizeof(my_struct_2)<<endl;//16
    cout<<sizeof(my_struct_3)<<endl;//14
    cout<<sizeof(my_struct_4)<<endl;//16
    cout<<sizeof(my_struct_5)<<endl;//14
    cout<<sizeof(my_struct_6)<<endl;//5
    cout<<sizeof(my_struct_7)<<endl;//12

    cout<<sizeof(test)<<endl;//12

    system("pause");
    return 0;
}

C语言字节对齐详解

C语言字节对齐12345