C语言内存字节对齐规则20180718

C语言的字节对齐及#pragmapack的使用C编译器的缺省字节对齐方式（自然对界）在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间。

在结构中，编译器为结构的每个成员按其自然对界（alignment）条件分配空间。

各个成员按照它们被声明的顺序在内存中顺序存储（成员之间可能有插入的空字节），第一个成员的地址和整个结构的地址相同。

C编译器缺省的结构成员自然对界条件为“N字节对齐”，N即该成员数据类型的长度。

如int型成员的自然对界条件为4字节对齐，而double类型的结构成员的自然对界条件为8字节对齐。

若该成员的起始偏移不位于该成员的“默认自然对界条件”上，则在前一个节面后面添加适当个数的空字节。

C编译器缺省的结构整体的自然对界条件为：该结构所有成员中要求的最大自然对界条件。

若结构体各成员长度之和不为“结构整体自然对界条件的整数倍，则在最后一个成员后填充空字节。

例子1（分析结构各成员的默认字节对界条界条件和结构整体的默认字节对界条件）:struct Test{char x1; // 成员x1为char型(其起始地址必须1字节对界)，其偏移地址为0char x2; // 成员x2为char型(其起始地址必须1字节对界，其偏移地址为1float x3; // 成员x3为float型(其起始地址必须4字节对界)，编译器在x2和x3之间填充了两个空字节，其偏移地址为4char x4; // 成员x4为char型(其起始地址必须1字节对界)，其偏移地址为8};因为T est结构体中，最大的成员为flaot x3，因些此结构体的自然对界条件为4字节对齐。

则结构体长度就为12字节，内存布局为1100 1111 1000。

例子2：#include <stdio.h>//#pragma pack(2)typedef struct{int aa1; //4个字节对齐 1111char bb1;//1个字节对齐 1short cc1;//2个字节对齐 011char dd1; //1个字节对齐 1} testlength1;int length1 = sizeof(testlength1); //4个字节对齐，占用字节1111 1011 1000,length = 12typedef struct{char bb2;//1个字节对齐 1int aa2; //4个字节对齐 01111short cc2;//2个字节对齐 11char dd2; //1个字节对齐 1} testlength2;int length2 = sizeof(testlength2); //4个字节对齐，占用字节1011 1111 1000,length = 12typedef struct{char bb3; //1个字节对齐 1char dd3; //1个字节对齐 1int aa3; //4个字节对齐 001111short cc23//2个字节对齐 11} testlength3;int length3 = sizeof(testlength3); //4个字节对齐，占用字节1100 1111 1100,length = 12typedef struct{char bb4; //1个字节对齐 1char dd4; //1个字节对齐 1short cc4;//2个字节对齐 11int aa4; //4个字节对齐 1111} testlength4;int length4 = sizeof(testlength4); //4个字节对齐，占用字节1111 1111,length = 8int main(void){printf("length1 = %d.\n",length1);printf("length2 = %d.\n",length2);printf("length3 = %d.\n",length3);printf("length4 = %d.\n",length4);return0;}改变缺省的对界条件(指定对界)· 使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。

字节对齐原则这个问题也是困扰了我很久的⼀个问题：为了加快数据存取的速度,编译器默认情况下会对结构体成员和结构体本⾝存储位置进⾏处理,使其存放的起始地址是⼀定字节数的倍数,⽽不是顺序存放,称为字节对齐.设对齐字节数为n(n = 1,2,4,8,16),每个成员内存长度为Li,Max(Li)为最⼤的成员内存长度,字节对齐规则是:1. 结构体对象的起始地址能够被Max(Li)所整除;2. 结构体中每个成员相对于起始地址的偏移量,即对齐值应是min(n,Li)的倍数.若不满⾜对齐值的要求,编译器会在成员之间填充若⼲个字节;3. 结构体的总长度值应是min(n,Max)(Li)的倍数,若不满⾜总长度值的要求,编译器在为最后⼀个成员分配空间后,会在其后填充若⼲个字节. (VC默认的对齐字节数n=8)开不懂，请看下⾯例⼦：#include <iostream>using namespace std;// 1加1+编译器补充的2个再加上int 的4个(编译器⾃动加的)typedef struct node1 // 1+1+(2)+4 = 8{char c1;char c2;int a;}str1 ;typedef struct str2 // 1+(3)+4+1+(3) = 12{char c1;int a;char c2;}str2 ;typedef struct str3 // 5+(3)+4+2+(2) = 16{char c1[5];int b;short c;}str3 ;typedef struct str4 // 5+(1)+(2)+4 = 12{char c1[5];short c;int b;}str4 ;typedef struct str5 // 1+1+(6)+8 = 16{char c1;char c2;double a;}str5 ;typedef struct str6 // 1+(7)+8+1+(7) = 24{char c1;double a;char c2;}str6 ;typedef struct str7{char c1;str1 s; // 相当于吧str1的结构放在这 char,char,intdouble b;}str7 ; // 1+1+1+(1)+4+4 = 12int main(){str1 s1;str2 s2;str3 s3;str4 s4;str5 s5;str5 s6;str7 s7;str8 s8;cout << "s1 = " << sizeof(s1)<<endl;cout << "s2 = " << sizeof(s2)<<endl; cout << "s3 = " << sizeof(s3)<<endl; cout << "s4 = " << sizeof(s4)<<endl; cout << "s5 = " << sizeof(s5)<<endl; cout << "s6 = " << sizeof(s6)<<endl; cout << "s7 = " << sizeof(s7)<<endl; cout << "s8 = " << sizeof(s8)<<endl; return0;}图解：str1str2：str3：str4：str5：str6：。

c语言字节对齐原理C语言中的字节对齐原理是指在内存中分配变量存储空间时，为了提高访问效率和内存利用率，系统会按照一定的规则进行对齐操作。

字节对齐原理在C语言中非常重要，对于程序的正确性和性能都有着重要的影响。

字节对齐的原理是为了优化内存访问速度和空间利用率，避免因为不对齐而导致的性能降低。

在C语言中，变量的存储空间是以字节为单位进行分配的，而不同的数据类型在内存中所占的字节数是不同的。

字节对齐的目的是为了确保不同类型的变量在内存中的起始地址是对齐的，这样可以提高访问效率。

C语言中的字节对齐规则是由编译器来决定的，不同的编译器可能有不同的对齐规则。

一般来说，编译器会按照变量的自然对齐大小进行对齐。

自然对齐是指变量所占的字节数，例如char类型的变量自然对齐为1字节，int类型的变量自然对齐为4字节。

在进行字节对齐时，编译器会在变量之间插入一些空白字节，使得变量的起始地址能够满足对齐要求。

这样一来，虽然会浪费一些空间，但可以提高内存的访问效率。

例如，如果int类型的变量要求按4字节对齐，而其起始地址为0x1000，那么在其后紧接着的变量的起始地址就必须是0x1004，即起始地址必须是4的倍数。

字节对齐的规则并不是固定的，它受到编译器的影响。

有些编译器的默认对齐规则可能是按照变量的自然对齐大小来对齐的，而有些编译器可能会有一些特殊的对齐规则。

此外，开发人员也可以通过编译器提供的指令来手动控制字节对齐的方式。

字节对齐的原理和规则虽然复杂，但它对于程序的正确性和性能优化至关重要。

如果变量没有按照正确的对齐方式进行存储，可能会导致内存访问错误，甚至引发程序崩溃。

而且，字节对齐也会影响程序的性能，如果变量没有按照对齐要求进行存储，可能会导致内存访问速度变慢，从而影响程序的执行效率。

为了正确地使用字节对齐，开发人员需要了解编译器的对齐规则，并且在编写代码时遵循这些规则。

在一些特殊情况下，开发人员也可以使用编译器提供的指令来手动控制字节对齐的方式，以满足特定的需求。

C语言结构体中的数组字节对齐在C语言中，结构体是一种用户自定义的数据类型，用于将不同类型的数据组合在一起。

结构体中常常包含多个成员变量，其中可能有数组类型的成员变量。

在结构体中使用数组时，需要了解数组字节对齐的概念和规则，以确保内存的最佳利用和访问的效率。

什么是字节对齐字节对齐是指在将数据存储在计算机内存中时，按照特定规则进行调整，以确保数据的存储和访问的效率。

字节对齐的规则可以对齐数据的起始地址或者数据的长度。

计算机中的数据存储是按照字节(Byte)来划分的，一个字节通常由8个二进制位组成。

字节对齐的主要目的是为了节省内存和提高访问效率。

在C语言中，结构体中的成员变量通常按照字节对齐的规则来排列。

C语言结构体中的数组字节对齐规则在C语言中，结构体中的数组字节对齐规则通常遵循以下原则：1.结构体的起始地址必须是所有成员变量所要求对齐方式的最小公倍数。

2.结构体中的每个成员变量的地址必须是它本身的大小的整数倍。

3.结构体的总大小必须是其最大成员变量大小的整数倍。

根据字节对齐规则，如果结构体中的成员变量的累计大小不是字节对齐的倍数，编译器会在成员变量之间添加填充字节，以满足对齐要求。

这些填充字节在结构体的占用空间中不可访问。

填充字节的目的是将后续成员变量的地址对齐，以提高内存访问效率。

数组字节对齐的示例为了更好地理解数组字节对齐的规则，我们来看一个示例。

#include <stdio.h>struct MyStruct {char c;int i;char arr[3];};int main() {struct MyStruct s;printf("sizeof(MyStruct) = %lu\n", sizeof(struct MyStruct));printf("sizeof(s.c) = %lu\n", sizeof(s.c));printf("sizeof(s.i) = %lu\n", sizeof(s.i));printf("sizeof(s.arr) = %lu\n", sizeof(s.arr));return 0;}输出结果：sizeof(MyStruct) = 12sizeof(s.c) = 1sizeof(s.i) = 4sizeof(s.arr) = 3在这个示例中，我们定义了一个包含一个字符类型变量、一个整型变量和一个长度为3的字符数组的结构体MyStruct。

C语言字节对齐字节对齐的由来程序在运行时会将数据临时存放在内存中，芯片内核需要对这些数据进行计算，不断的读取内存以获得数据，并将计算结果写入内存。

计算机体系经过若干年的发展，最终确定了以8bits作为其基本的存储单元——byte（字节），这是每个地址所对应的最小访问单元，在C语言中对应一个char型的变量。

下图为芯片内核访问内存的示意图。

芯片内核通过控制总线控制内存的动作，通过地址总线告知内存地址，数据总线上出现交互的数据。

图1访问内存示意图假设上图是8位机的示意图，那么数据总线的宽度是8bits，由8根数据线组成，这样芯片内核与内存之间一次就可以同时交换8个bits的数据，正好是一个字节。

图中右侧的每个小格子代表一个存储地址，对应一个字节。

下面通过一段C语言代码来具体看看芯片内核与内存之间的数据交互过程。

char data[2];data[0]=2;data[1]=data[0]+1;第一行代码定义了2个字节的数组data。

假设data数组被编译到地址0x100，那么data[0]这个字节就被存储在地址为0x100的内存空间，data[1]这个字节就被存储在地址为0x101的内存空间。

第二行对应的硬件动作是将数据2存入到data[0]中，也就是将数据2存入到内存中的0x100地址，执行这条语句时，芯片内核对控制总线、地址总线和数据总线进行操作，控制总线上出现写信号，地址总线上出现数据0x100，数据总线上出现数据0x02。

此时内存就知道需要将数据2写入到地址0x100中，完成一次写操作。

第三行先读出data[0]中的数据，芯片内核将控制总线置为读信号，将地址总线置为0x100，此时，内存就会从其内部取出0x100地址中的数据，也就是数据2，2将出现在数据总线上，此时芯片内核就会通过数据总线读取到data[0]中的数据了。

接下来芯片内核计算2+1=3，需要将数字3写入到data[1]中，芯片内核将控制总线置为写信号，将地址总线置为0x101，将数据总线置为3，内存接收到这些信号后，就会将数据3存入到其内部0x101地址中，完成本次操作。

c语言结构体内存对齐规则C语言结构体内存对齐规则一、引言在C语言中，结构体是一种用户自定义的数据类型，它可以包含不同类型的数据成员，这些数据成员按照一定的内存对齐规则在内存中排列。

本文将介绍C语言结构体内存对齐的规则和原因，以及如何通过调整结构体成员的顺序和插入填充成员来优化内存使用效率。

二、内存对齐的原因内存对齐是为了提高程序的运行效率和节省内存空间。

当结构体成员按照自然对齐的方式排列时，访问这些成员的速度更快。

此外，内存对齐还可以避免由于数据成员在内存中的存放位置不一致而导致的访问错误。

三、内存对齐的规则1. 基本对齐规则：结构体成员的起始地址必须是该成员大小的整数倍。

例如，一个4字节大小的成员必须从4字节对齐的地址开始。

2. 数据成员的对齐规则：C语言中的基本数据类型在内存中的对齐要求如下：- char类型的对齐要求为1字节；- short类型的对齐要求为2字节；- int类型的对齐要求为4字节；- long类型的对齐要求为8字节；- float类型的对齐要求为4字节；- double类型的对齐要求为8字节；- 指针类型的对齐要求为4字节或8字节，取决于系统的位数。

3. 结构体成员的对齐规则：结构体成员的对齐要求为其自身大小和当前对齐基数中较小的那个。

对齐基数是指前面所有成员中最大的对齐要求。

例如，如果前面的成员中最大的对齐要求为4字节，而当前成员的大小为2字节，则当前成员的对齐要求为2字节。

4. 结构体的总大小：结构体的总大小是所有成员大小之和，但是要满足对齐规则，可能需要插入一些填充成员。

填充成员的大小取决于对齐基数和当前成员的对齐要求之间的差距。

四、内存对齐的例子假设有如下结构体定义：```struct example {char c;int i;short s;};```根据内存对齐的规则，该结构体的对齐基数为4字节（int类型的对齐要求），因此，结构体的总大小应为12字节。

在内存中的排列方式如下：```| c |填充| i | s |```其中，c占用1字节，i占用4字节，s占用2字节。

【C语⾔】字节对齐（内存对齐）数据对齐1）平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常2）硬件原因：经过内存对齐之后，CPU的内存访问速度⼤⼤提升。

1. 对齐原则：【原则1】数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第⼀个数据成员放在offset为0的地⽅，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员⾃⾝长度中，⽐较⼩的那个进⾏。

【原则2】结构(或联合)的整体对齐规则：在数据成员完成各⾃对齐之后，结构(或联合)本⾝也要进⾏对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最⼤数据成员长度中，⽐较⼩的那个进⾏。

【原则3】结构体作为成员：如果⼀个结构⾥有某些结构体成员，则结构体成员要从其内部最⼤元素⼤⼩的整数倍地址开始存储。

备注：数组成员按长度按数组类型长度计算，如char t[9],在第1步中数据⾃⾝长度按1算，累加结构体时长度为9；第2步中，找最⼤数据长度时，如果结构体T有复杂类型成员A，该A成员的长度为该复杂类型成员A的最⼤成员长度。

⼩结：当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的⼤⼩将不产⽣任何效果。

【注意】（对齐位数跟处理器位数和编译器都有关）VS, VC等编译器默认是#pragma pack(8)，所以测试我们的规则会正常；注意gcc默认是#pragma pack(4)，并且gcc只⽀持1,2,4对齐。

套⽤三原则⾥计算的对齐值是不能⼤于#pragma pack指定的n值。

2. ⾃然对齐：存放变量的地址要是该变量数据类型⼤⼩的整数倍。

如：存放int型数据的地址⼀定要是4的倍数，存放short型数据的地址⼀定要是2的倍数。

3. 改变缺省的对界条件(指定对界)：使⽤伪指令#pragma pack (n)，C编译器将按照n个字节对齐。

c结构体字节对齐规则在C语言中，结构体是一种自定义数据类型，用于组合不同类型的变量。

结构体的内存布局是由字节对齐规则决定的。

字节对齐是为了优化内存访问效率和提高程序性能而设计的。

本文将详细介绍C结构体的字节对齐规则。

字节对齐是指结构体中各个成员变量在内存中的对齐方式。

由于硬件和操作系统的不同，字节对齐的规则也可能有所差异。

C语言的标准并没有规定具体的字节对齐规则，而是由编译器来自行决定。

在不同的编译器中，字节对齐规则可能有所不同。

C结构体的字节对齐规则遵循以下原则：1. 自然对齐：结构体的起始地址必须是其成员变量中字节对齐要求的整数倍。

例如，对齐要求为4字节的成员变量必须从4的倍数地址开始。

2. 最大对齐原则：结构体的字节对齐要求取决于其成员变量中对齐要求最高的成员。

对齐要求高的成员变量的起始地址必须是其对齐要求的整数倍。

3. 结构体对齐：结构体本身也要进行字节对齐，其对齐要求取决于结构体中最大对齐要求的成员变量。

4. 成员变量顺序：结构体中的成员变量按照定义的顺序排列。

如果中间存在对齐填充的空间，则会在成员变量之间插入。

下面以一个例子来说明C结构体字节对齐规则：```cstruct Example {char a;int b;char c;};```在这个例子中，结构体`Example`中包含三个成员变量：`a`、`b`和`c`。

`a`和`c`的类型为`char`，`b`的类型为`int`。

在大多数编译器中，`char`类型的对齐要求为1字节，`int`类型的对齐要求为4字节（根据具体的编译器和操作系统可能有所不同）。

根据最大对齐原则，结构体`Example`的对齐要求为4字节，因为`b`的对齐要求最高。

因此，`a`的起始地址为0，`b`的起始地址为4，`c`的起始地址为8。

`a`和`c`之间会插入两个字节的对齐填充。

根据以上规则，结构体的大小为12字节（4字节对齐）。

可以通过`sizeof`运算符来验证结构体的大小：```cprintf("Size of struct Example: %zu\n", sizeof(struct Example));```输出结果应为12。

字节对齐（强制对齐以及⾃然对齐）struct {}node;32为的x86，window下VC下sizeof(node)的值为1，⽽linux的gcc下值为0；⼀、WINDOWS下（VC--其实GCC和其原理基本⼀样，象这种问题，⼀般要查具体的编译器设置）字节对齐的规则：1、⼀般设置的对齐⽅式为1，2，4字节对齐⽅式，VC⼀般默认为4字节(最⼤为8字节)。

结构的⾸地址必须是结构内最宽类型的整数倍地址；另外，结构体的每⼀个成员起始地址必须是⾃⾝类型⼤⼩的整数倍(需要特别注意的是windows下是这样的，但在linux的gcc编译器下最⾼为4字节对齐），否则在前⼀类型后补0；这⾥特别提到的是数组⼀定要注意，⽽且在⼀些编程的技巧中，我们可以使⽤数组强制字节达到对齐的⽬的。

这在⽹络编程中是很常见的。

举例：⽐如CHAR型占⽤空间为1字节，则其起始位置必须可被1整除。

INT为4字节，其起始位置必须被4带队，依次类推。

（我们假定类或结构体的起始位置为0位置，其实编译器是在开辟空间时，会寻找起始位置可被结构内最宽类型整除的地址做为开始地址，因此我们可以假定其为0值，因为这0值可以被任意的类型整除。

）2、结构体的整体⼤⼩必须可被对齐值整除，默认4（默认，且结构中的类型⼤⼩都⼩于默认的4）。

3、结构体的整体⼤⼩必须可被本结构内的最宽类型整除。

（其实和上⼀条是⼀样的，但这⾥独⽴出来，起注意作⽤。

⽐如结构体⾥的有DOUBLE，那么结构的⼤⼩最后必须可被8整除）注意：GCC不是这样，就是最⾼只能被4整除，它是个死的。

否则（2、3条），编译器会在结构的最后添充⼀定的特定字符来补齐。

struct T{char ch;double d ;};在VC中是16个字节，GCC中为12个字节。

4、对于结构体内嵌套结构体的形势，规定是必须按照基本数据类型来定义，⽽不能以嵌套结构⼤⼩来做为上三种使⽤的基准。

⼆、举例：struct A{int a;char b;short c;};struct B{char b;int a;short c;};struct C{double t;char b;int a;short c;};struct D{char b;double t;int a;short c;};在VC中，SIZEOF这四个结构体，分别为：8、12、24、24；我们先谈第⼀个，（说明⼀下，在考虑结构体⼤⼩时，我们基本可以忽略起始地址的问题，因为这个编译器会⾃动为我们做好，见上⾯的说明），结构体内⾸先是⼀个INT的4字节，起始地址假定为0，整除4，其⼩于等于默认的4字节对齐且0为4（INT的占⽤空间）的整数倍，所以，其占四个字节；其后为起始地址为5，空间为1个字节的CHAR，⼩于4且5为1（CHAR占⽤空间）的整数倍，故占⽤1个字节，然后是⼀个起始地址为5占2个字节的SHORT，其⼩于4，但5不为2的整数倍，故补齐⼀个字节，从第6个字节开始，占2字节空间。

内存字节对齐算法
内存管理中经常使用字节对齐来分配内存，有关字节对齐的算法如下：
1 原理：
2字节对齐，要求地址位为2,4,6,8...，要求二进制位最后一位为0（2的1次方）
4字节对齐，要求地址位为4,8,12,16...，要求二进制位最后两位为0（2的2次方）
8字节对齐，要求地址位为8,16,24,32...，要求二进制位最后三位为0（2的3次方）
16字节对齐，要求地址位为16,32,48,64...，要求二进制位最后四位为0（2的4次方）
...
由此可见，我们只要对数据补齐对齐所需最少数据，然后将补齐位置0就可以实现对齐计算。

2 字节对齐实现：
#define ROUND_UP(x, align) (x+(align-1))&~(align-1)
align为2，2字节对齐
align为4，4字节对齐
align为8，8字节对齐
...
3 字节对齐算法：
（1）(align-1)，表示对齐所需的对齐位，如：2字节对齐为1，4字节为11，8字节为111，16字节为1111...
（2）(x+(align-1))，表示x补齐对齐所需数据
（3）&~(align-1)，表示去除由于补齐造成的多余数据
（4） (x+(align-1))&~(align-1)，表示对齐后的数据
举个例子：如8字节对齐。

起始地始是6
6 + （8 - 1）=0000 0110 + 0000 0111 = 0000 1101
0000 1101 & ~(0000 0111) = 0000 1000 //去除由于补齐造成的多余数据。