字节对齐
C语言的字节对齐及#pragmapack的使用
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语言中，变量的存储空间是以字节为单位进行分配的，而不同的数据类型在内存中所占的字节数是不同的。
字节对齐的目的是为了确保不同类型的变量在内存中的起始地址是对齐的，这样可以提高访问效率。
C语言中的字节对齐规则是由编译器来决定的，不同的编译器可能有不同的对齐规则。
一般来说，编译器会按照变量的自然对齐大小进行对齐。
自然对齐是指变量所占的字节数，例如char类型的变量自然对齐为1字节，int类型的变量自然对齐为4字节。
在进行字节对齐时，编译器会在变量之间插入一些空白字节，使得变量的起始地址能够满足对齐要求。
这样一来，虽然会浪费一些空间，但可以提高内存的访问效率。
例如，如果int类型的变量要求按4字节对齐，而其起始地址为0x1000，那么在其后紧接着的变量的起始地址就必须是0x1004，即起始地址必须是4的倍数。
字节对齐的规则并不是固定的，它受到编译器的影响。
有些编译器的默认对齐规则可能是按照变量的自然对齐大小来对齐的，而有些编译器可能会有一些特殊的对齐规则。
此外，开发人员也可以通过编译器提供的指令来手动控制字节对齐的方式。
字节对齐的原理和规则虽然复杂，但它对于程序的正确性和性能优化至关重要。
如果变量没有按照正确的对齐方式进行存储，可能会导致内存访问错误，甚至引发程序崩溃。
而且，字节对齐也会影响程序的性能，如果变量没有按照对齐要求进行存储，可能会导致内存访问速度变慢，从而影响程序的执行效率。
为了正确地使用字节对齐，开发人员需要了解编译器的对齐规则，并且在编写代码时遵循这些规则。
在一些特殊情况下，开发人员也可以使用编译器提供的指令来手动控制字节对齐的方式，以满足特定的需求。
c语言结构体中的数组字节对齐
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语言字节对齐
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地址中，完成本次操作。
256字节对齐计算公式
256字节对齐计算公式1.引言在计算机领域，内存对齐是一种重要的概念，它与数据在内存中的存放方式密切相关。
其中，256字节对齐是一种常见的对齐方式。
本文将介绍256字节对齐的计算公式，帮助读者更好地理解和应用该对齐方式。
2.什么是内存对齐内存对齐是指变量在内存中存放时按照一定的规则对其进行排列的过程。
由于计算机硬件读取数据的机制，对齐可以提高数据的读取效率。
对齐通常以字节为单位进行，比如4字节对齐、8字节对齐等。
3.为什么选择256字节对齐在某些应用场景下，特别是在嵌入式系统或高性能计算中，选择256字节对齐可以获得更好的性能。
这是因为256字节对齐可以最大限度地利用计算机硬件的特性，提高数据的读取和处理效率。
4. 256字节对齐计算公式假设需要存放的变量为V（以字节为单位），256字节对齐的计算公式如下：A l ig ne dA dd re ss=((V+255)/256)*256其中，A li gn ed Ad dr e ss表示对齐后的起始地址。
5.举例说明为了更好地理解256字节对齐计算公式，我们来看一个具体的例子。
假设有一个结构体需要存放在内存中，其成员变量分别为：i n ta;c ha rb;d ou ble c;这三个变量的字节大小分别为4、1和8字节。
编译器为了对齐考虑，会按照最大字节大小的变量进行对齐，即8字节对齐。
首先，计算出结构体在内存中的大小：4+1+8=13字节。
然后，按照256字节对齐计算公式进行计算：A l ig ne dA dd re ss=((13+255)/256)*256=512即结构体在内存中的起始地址为512字节。
6.总结256字节对齐是一种常见的内存对齐方式，可以提高数据在内存中的读取和处理效率。
本文介绍了256字节对齐的计算公式，并通过一个具体的例子进行了说明。
希望读者通过本文的介绍，对256字节对齐有更深入的理解，并能在实际的项目中合理应用。
1字节对齐定义
1字节对齐定义摘要：1.1 字节对齐的定义2.1 字节对齐的应用场景3.1 字节对齐的实现方法4.1 字节对齐的优缺点正文：1 字节对齐是一种计算机编程中的数据存储和处理技术，指的是在数据存储或传输过程中，每个数据项的开始位置都与其大小对齐，即数据的地址与其大小的整数倍对齐。
这种对齐方式可以提高数据处理的效率，特别是在大规模数据处理和传输过程中，可以减少数据处理的时间和成本。
1 字节对齐的应用场景主要包括以下几种：一是在网络传输中，对数据进行1 字节对齐可以减少传输的时间和带宽的占用。
例如，在HTTP 协议中，如果数据包的大小不是整数倍，就需要进行数据填充，以达到1 字节对齐的要求。
二是在数据存储中，对数据进行1 字节对齐可以提高存储的效率和速度。
例如，在硬盘存储中，如果数据的大小不是512 字节的整数倍，就需要进行数据填充，以达到512 字节的整数倍，这样可以提高硬盘的读写速度。
三是在数据处理中，对数据进行1 字节对齐可以提高处理的效率和精度。
例如，在图像处理中，如果图像的大小不是整数倍，就需要进行图像填充，以达到整数倍的要求，这样可以提高图像处理的精度和速度。
1 字节对齐的实现方法主要包括以下几种：一是数据填充。
在进行数据存储或传输时，如果数据的大小不是整数倍，就需要进行数据填充，以达到整数倍的要求。
二是数据截取。
在进行数据存储或传输时，如果数据的大小超过整数倍，就需要进行数据截取，以达到整数倍的要求。
三是数据转换。
在进行数据存储或传输时，如果数据的大小不能被整除，就可以通过数据转换的方式，将其转换为可以被整除的大小。
1 字节对齐的优缺点主要包括以下几点：优点：可以提高数据处理的效率和精度，特别是在大规模数据处理和传输过程中，可以减少数据处理的时间和成本。
内存字节对齐原则
内存字节对齐原则1. 说起内存字节对齐，这可是计算机里的一门"整理艺术"！就像咱们收拾房间一样，东西不能乱放，得讲究摆放的位置，让拿取更方便。
2. 想象一下，内存就是一个超大的储物柜，每个格子都是一个字节。
为了存取效率，咱们得把数据像叠积木一样整整齐齐地放进去，这就是对齐的妙处。
3. 对齐的基本规则可有意思了！就拿四字节数据来说，它就像个"矜持"的大爷，非得住在能被4整除的门牌号上。
要是住在不合适的地方，那可不行，非得浪费几个小格子不可。
4. 为啥要这么讲究呢？这就跟咱们买菜一样。
一次性买够一袋子的菜，跑一趟就够了；要是零零散散地买，就得多跑好几趟，多费劲啊！5. 来个实在的例子：假如咱们有个结构体，里面放了一个字节的小数据，后面跟着四字节的大数据。
按理说只需要5个格子，但实际上可能占用8个格子！那多出来的空格子就像是大数据的"专属停车位"，必须得留着。
6. 有的小伙伴可能要问了：这不是浪费空间吗？诶，这就像是超市购物，散装商品非得按整袋买，虽然可能用不完，但买起来更便宜更快捷啊！7. 不同的处理器还有不同的小脾气。
有的处理器要求严格，数据必须严丝合缝地对齐，就像军训时候站队一样；有的处理器比较随意，不对齐也能工作，就是速度慢点。
8. 编译器在处理这事儿的时候可聪明了，它会自动帮咱们在需要的地方加入"填充字节"。
这些填充字节就像是结构体里的"弹簧垫"，把该撑开的地方撑开，保证后面的数据能对齐。
9. 要是想节省空间，咱们还可以玩个小花招：把大小相近的成员放一起！就像收拾行李箱，把大件放一起，小件放一起，这样就能省出不少空间。
10. 有意思的是，有时候看起来更小的结构体，实际占用的空间可能更大。
这就跟收拾房间似的，摆放整齐的东西可能占地方更多，但找起来更方便！11. 在写代码的时候，要是特别在意内存使用，可以用特殊的指令告诉编译器：不用对齐了，能省则省。
结构体字节对齐最简单的解释
有效对齐值与以下两种对齐值有关
1、 自身对齐值
对于单一变量，自身对齐值就是该变量所占的内存大小。
对于结构体变量，自身对齐值就是结构体成员自身对齐值中最 大的一个。
2、 指定对齐值
用程序自定对齐值。
#pragma pack(2)
//开始
#pragma pack()
//结束
代表指定 2 字节对齐
如果没有指定对齐值，那么有效对齐值就是变量的自身对齐值；如果指 定对齐值，那么有效对齐值就是这两个对齐值中的小者。
由以上说明就可以知道一个结构体变量所占的真实字节数了。
下例中所有结构体的起始地址都假设从 0 开始
例 1：
struct a
{
char no[10]; //没有指定对齐值，所有有效对齐值为自身对齐值，即
1;所以占用地址 0--9
int p;
//没有指定对齐值，所有有效对齐值为自身对齐值，即 4；
所以占用地址 12--15
long int pp; //没有指定对齐值，所有有效对齐值为自身对齐值，即
4；所以占用地址 16--19
unsigned int ppp;// 没有指定对齐值，所有有效对齐值为自身对齐
值，即 4；所以占用地址 20--23
char x; //没有指定对齐值，所有有效对齐值为自身对齐值，即 1;
所以占用地址 24
个成员结束后，所占的内存空间大小已经是有效对齐值的
整数倍了，所以不需要再加上填充字节了。
} xy;
例 2： struct S1 { char c; int i; }; struct S3 { char c1; S1 s; char c2; };
//占 8 字节 //占 16 字节
什么是字节对齐,为什么要对齐
什么是字节对齐,为什么要对齐一.什么是字节对齐,为什么要对齐?一.什么是字节对齐,为什么要对齐?现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。
一些平台对某些特定类型的数据只能从某些特定地址开始存取。
比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。
比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。
显然在读取效率上下降很多。
二.字节对齐对程序的影响:先让我们看几个例子吧(32bit,x86环境,gcc编译器):设结构体如下定义：struct A{char b;short c;};struct B{char b;int a;short c;};现在已知32位机器上各种数据类型的长度如下:char:1(有符号无符号同)short:2(有符号无符号同)int:4(有符号无符号同)long:4(有符号无符号同)float:4 double:8那么上面两个结构大小如何呢?结果是:sizeof(strcut A)值为8sizeof(struct B)的值却是12结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
结构体字节对齐的方法
结构体字节对齐的方法全文共四篇示例，供读者参考第一篇示例：结构体字节对齐是编程中一个非常重要的概念，尤其在涉及到内存对齐的底层编程中更是不可或缺。
在结构体的定义中，每个元素都需要在内存中占用一定的空间，而结构体整体的大小受到字节对齐规则的限制。
本文将介绍结构体字节对齐的方法及其原理，希望能帮助读者更好地理解和掌握这一概念。
一、什么是字节对齐字节对齐是指在结构体中每个元素按照特定的规则分配内存空间，以便提高内存读取的效率。
在计算机系统中，一般要求数据在内存中的存储地址是某个特定值的倍数，这个特定值就是对齐系数。
常用的对齐系数有1、2、4、8等，根据不同的系统和编译器，对齐系数可能会有所不同。
二、结构体字节对齐的原理在C语言中，结构体的内存对齐是通过编译器来进行处理的。
当定义一个结构体时，编译器会按照一定的规则对结构体中的元素进行字节对齐，以便提高读取效率。
具体的对齐规则如下：1. 结构体中每个元素的偏移量必须是它自身类型大小的整数倍。
2. 结构体的大小必须是最大元素类型大小的整数倍。
3. 结构体的对齐系数为结构体中所有元素类型大小的最大值。
通过这些规则，编译器可以在编译时确定结构体的大小，并根据对齐系数进行内存对齐，从而提高内存访问的效率。
1. 使用#pragma pack指令在C语言中，可以使用#pragma pack指令来改变编译器默认的对齐系数。
通过指定pack(n)来设置n值，表示结构体的对齐系数为n。
这样可以在需要的时候自定义结构体的对齐系数，提高程序的效率。
```c#pragma pack(1)struct Student {char name[10];int age;float score;};```上面的代码中，通过#pragma pack(1)改变了结构体的对齐系数为1，从而可以确保结构体中的每个元素都按照一个字节进行对齐。
2. 使用__attribute__((packed))关键字在GCC编译器中，可以使用__attribute__((packed))关键字来实现对齐系数的设置。
字节对齐（强制对齐以及自然对齐）
字节对齐（强制对齐以及⾃然对齐）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字节空间。
字节对齐作用
字节对齐作用字节对齐作用什么是字节对齐字节对齐是一种数据存储方式，用于提高计算机内存的读取效率。
在计算机中，数据被存储为字节的形式，每个字节有固定的大小。
字节对齐的原理计算机在读取数据时，通常以字节为单位进行操作。
为了提高读取效率，计算机会将数据按照一定规则进行对齐。
字节对齐的原理是按照数据类型的大小，将数据存储在内存中的地址按照一定规则进行调整，使得数据可以更快地被读取和处理。
字节对齐的作用字节对齐在计算机中具有重要的作用，主要体现在以下几个方面：•提高读取效率：字节对齐可以减少对内存的读取次数，提高读取效率。
当数据按照自然边界对齐时，可以通过一次读取多个字节，减少读取的次数，提高数据读取的效率。
•节省存储空间：字节对齐可以减少内存空间的浪费。
当数据按照对齐规则进行对齐时，可以利用内存中的空闲字节，避免空间的浪费，节省存储空间。
•确保数据的连续存储：字节对齐可以保证数据在内存中的连续存储，减少内存碎片的产生。
当数据按照对齐规则进行对齐时，可以确保数据之间没有空隙，避免内存碎片的产生，提高内存的利用率。
•增加数据的可移植性：字节对齐可以增加数据的可移植性。
不同的计算机体系结构对字节对齐的要求可能不同，通过字节对齐可以保证数据在不同的计算机上都可以正确地读取和处理。
字节对齐的规则字节对齐的规则取决于具体的编程语言和计算机体系结构。
在C语言中，常用的字节对齐规则是按照数据类型的大小进行对齐，即数据类型的长度必须是其对齐要求的整数倍。
具体的对齐规则可以通过编译器的选项或者编程语言的特定语法进行设置和控制。
以下是常见的对齐规则：•对齐到自然边界：数据类型按照自身的大小进行对齐。
例如，一个int类型的数据通常按照4字节对齐。
•对齐到指定边界：数据类型按照指定的边界进行对齐。
例如，一个结构体可以通过设置#pragma pack(n)指令，将其对齐到n字节的边界。
•默认对齐规则：编译器根据具体的体系结构和编译选项进行对齐。
详解4字节对齐
详解4字节对齐所谓的字节对齐，就是各种类型的数据按照⼀定的规则在空间上排列，⽽不是顺序的⼀个接⼀个的排放，这个就是对齐。
我们经常听说的对齐在N上，它的含义就是数据的存放起始地址%N==0。
具体对齐规则会在下⾯的篇幅中介绍。
⾸先还是让我们来看⼀下，为什么要进⾏字节对齐吧。
各个硬件平台对存储空间的处理上有很⼤的不同。
⼀些平台对某些特定类型的数据只能从某些特定地址开始存取。
⽐如有些的CPU，诸如SPARC在访问⼀个没有进⾏对齐的变量的时候会发⽣错误，那么在这种架构上必须编程必须保证字节对齐。
⽽有些平台对于没有进⾏对齐的数据进⾏存取时会产⽣效率的下降。
让我们来以x86为例看⼀下如果在不进⾏对齐的情况下，会带来什么样⼦的效率低下问题，看下⾯的数据结构声明:view plaincopy to clipboardprint?01.struct A {02. char c;03. int i;04.};05.struct A a;Code 13-1假设变量a存放在内存中的起始地址为0x00，那么其成员变量c的起始地址为0x00，成员变量i的起始地址为0x01，变量a⼀共占⽤了5个字节。
当CPU要对成员变量c进⾏访问时，只需要⼀个读周期即可。
⽽如若要对成员变量i进⾏访问，那么情况就变得有点复杂了，⾸先CPU⽤了⼀个读周期，从0x00处读取了4个字节(注意由于是32位架构)，然后将0x01-0x03的3个字节暂存，接着⼜花费了⼀个读周期读取了从0x04-0x07的4字节数据，将0x04这个字节与刚刚暂存的3个字节进⾏拼接从⽽读取到成员变量i的值。
为了读取这个成员变量i，CPU花费了整整2个读周期。
试想⼀下，如果数据成员i的起始地址被放在了0x04处，那么读取其所花费的周期就变成了1，显然引⼊字节对齐可以避免读取效率的下降，但这同时也浪费了3个字节的空间(0x01-0x03)。
有了上述的基本概念之后，让我们来看⼀下，编译器是按照什么样的原则进⾏对齐的。
字节对齐规则
字节对齐规则1、什么是字节对齐字节对齐，又称为数据对齐，是把数据按一定的大小分割，并要求所有数据在内存中以固定长度的块或行的方式存放，即使用有限的内存来存放数据。
这种存储形式允许处理器快速地读取数据，而不需要每次都去进行移动。
2、字节对齐的优势字节对齐可以节省内存空间，减少了数据在内存中的跳跃存取，从而加快了数据读写速度，提高了处理器的性能。
此外，字节对齐的优势还包括：（1）可以提高程序的缓存命中率，减少内存访问时间。
（2）避免指令流水线停滞，提高指令的执行效率。
（3）可以提高内存访问的性能，减少内存引用等待时间。
（4）可以提高存储和处理数据的效率。
3、字节对齐的实现方式（1）在C/C++中，可以使用#pragma pack()指令，指定结构体或类型变量的字节对齐格式。
（2）在Python中，可以使用struct.pack()函数，指定数据的字节对齐格式。
（3）在Java中，可以使用ByteBuffer.allocateDirect()函数，指定数据的字节对齐格式。
4、字节对齐的常见应用（1）字节对齐的常见应用是在处理器上实现cache line的优化，将同一个cache line中的数据保持一致，从而减少cache miss的次数。
（2）字节对齐也可以应用于网络数据传输的优化，比如TCP/IP协议栈的改进，以及DMA设备的驱动程序的开发等。
（3）字节对齐还可以应用于软件优化，比如在游戏引擎中，可以使用字节对齐技术来优化游戏性能，从而提高游戏的流畅度和响应速度。
（4）字节对齐也可以应用于数据库索引的优化，比如在SQL Server中，可以使用字节对齐技术来提高检索数据的速度。
5、总结总之，字节对齐是指将数据按一定的大小分割，并要求所有数据在内存中以固定长度的块或行的方式存放，以便提高处理器的性能。
字节对齐可以节省内存空间，减少数据在内存中的跳跃存取，提高程序的缓存命中率，避免指令流水线停滞，提高内存访问的性能，提高存储和处理数据的效率，有助于提高计算机的性能。
c++中的字节对齐规则
struct A
{
int a;
char b;
short c;
};
struct B
{
char b;
int a;
short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)
6.对齐或非对齐读写访问带来问题
__packed struct STRUCT_TEST
{
char a;
int b;
char c;
} ; //定义如下结构此时b的起始地址一定是不对齐的
//在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
一.什么是字节对齐,为什么要对齐?
现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访
问特定类型变量的时候经常在特 定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一
个的排放，这就是对齐。
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
char b;agma pack () /*取消指定对齐，恢复缺省对齐*/
第 一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合
们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做 法是显式的插入reserved成员：
struct A{
char a;
char reserved[3];//使用空间换时间
字节对齐引起的内存空洞
字节对齐引起的内存空洞1.引言1.1 概述字节对齐是在计算机系统中，为了提高内存访问效率而采取的一种对齐内存存储的方法。
在计算机中，内存空间会被划分成一个个字节（byte），而字节对齐则指的是将数据存储在内存中的时候，按照一定规则将数据的起始地址作对齐调整。
字节对齐的原理是，由于计算机在内存中的存储是以字节为单位进行的，而CPU 从内存中读取数据时，会按照一个固定大小的单位（例如4字节或8字节）进行读取。
如果数据的起始地址不是这个固定单位的整数倍，那么CPU 需要进行多次读取才能将完整的数据读取出来，从而降低了内存访问的效率。
为了解决这个问题，字节对齐的概念被提出。
字节对齐的概念可以简单地理解为数据在存储时需要按照对齐规则将起始地址调整到特定的倍数上。
常见的对齐规则是按照数据类型的大小进行调整，例如char类型对齐到1字节，int类型对齐到4字节或8字节。
然而，字节对齐在提高内存访问效率的同时也会带来一些负面影响，即字节对齐引起的内存空洞。
当多个数据对象按照字节对齐规则存储在内存中时，为了满足对齐要求，可能会在数据之间留下一些未被使用的内存空间，从而导致内存空间的浪费。
这些未被使用的内存空间就是所谓的内存空洞。
本文将详细探讨字节对齐引起的内存空洞的产生原因和对系统性能的影响，并给出一些避免内存空洞的方法。
通过深入了解字节对齐的概念和原理，读者将能更好地理解字节对齐对于计算机系统的重要性，以及如何在实际开发中避免内存空洞所带来的问题。
1.2文章结构1.2 文章结构本文将以以下结构来讨论字节对齐引起的内存空洞的问题：1. 引言：[链接到1.引言部分]2. 正文：2.1 字节对齐的概念和原理：[链接到2.1 字节对齐的概念和原理部分]2.2 字节对齐引起的内存空洞的产生：[链接到2.2 字节对齐引起的内存空洞的产生部分]3. 结论：3.1 对字节对齐引起的内存空洞的影响：[链接到3.1 对字节对齐引起的内存空洞的影响部分]3.2 如何避免字节对齐引起的内存空洞：[链接到3.2 如何避免字节对齐引起的内存空洞部分]通过以上结构，我们将全面探讨字节对齐引起的内存空洞的问题，从字节对齐的概念和原理开始，分析字节对齐引起的内存空洞的产生原因，进一步讨论其对系统的影响，最后提供一些解决方案以避免字节对齐引起的内存空洞。
c语言字节对齐规则
c语言字节对齐规则
C语言字节对齐规则
字节对齐（Byte Alignment）是指内存地址和数据类型中字节的排列位置，由于内存地址以字节为单位进行分配，数据类型却有特定的字节内存空间，所以为了让数据类型跟内存地址对齐，就必须让数据类型的内存空间按照一定的对齐规则进行排列，这样才能让数据类型最小的内存空间能得到最优的分配。
C语言的字节对齐规则
1、C语言中，结构体的属性是以字节为单位进行分配的。
2、对于大小为1字节的变量，不管在结构体的哪个位置，都不会进行字节对齐，一个变量一个字节就是一个字节，不会增加其他字节的占用。
3、对于大小为2字节的变量，要求其在结构体的位置为偶数，将会对其右边多出一个字节的占用，但是不会多出一个字节的内存，只是在内存的右边多出一个字节的位置而已。
4、对于大小为4字节的变量，要求其在结构体的位置为4的倍数，也会对其右边多出三个字节的占用，但是不会多出三个字节的内存，只是在内存的右边多出三个字节的位置而已。
5、对于大小为8字节的变量，要求其在结构体的位置为8的倍数，也会对其右边多出七个字节的占用，但是不会多出七个字节的内存，只是在内存的右边多出七个字节的位置而已。
6、C中的枚举常量和指针类型都会进行字节对齐，枚举常量和
指针类型都会被当做int类型来对齐，即按照4个字节的方式对齐。
7、C语言中，数组也会进行字节对齐，但是这里需要根据该数组的元素的大小来决定字节对齐的规则，如果数组的元素大小是1字节，则不进行字节对齐；如果是2字节，则按照2字节对齐规则进行字节对齐；如果数组的元素大小是4字节，则按照4字节的对齐规则进行字节对齐；如果大于4字节，则按照8字节的对齐规则进行字节对齐。
字节对齐、8字节对齐
字节对齐、8字节对齐参考博文：参考1 、参考2、参考3在内存管理中经常使用字节对齐来管理分配的内存。
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次方）。
•…2、算法2.1unsigned int calc_align(unsigned int n,unsigned align){if ( n / align * align == n)return n;return (n / align + 1) * align;}2.2 更好的算法unsigned int calc_align(unsigned int n,unsigned align){return ((n + align - 1) & (~(align - 1)));}3、算法说明(1) (align - 1)：表示对齐所需的对齐位，如:•2字节对齐位为1；•4字节对齐位为11；•8字节对齐位111；•16字节对齐位为1111；•…(2) (n + align - 1)：表示n补齐对齐所需数据。
(3) &(~(align - 1))：表示去除由于补齐造成的多余数据。
(4) (n + align - 1) & (~(align - 1))：表示对齐后的数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
字节对齐Andrew Huang<bluedrum@>内容提要●字节对齐概念●字节对齐测试⏹offsetof⏹缺省情况的字节对齐⏹double 型字节对齐⏹改变字节对齐设置●不同环境下的字节对齐⏹GCC字节对齐⏹ADS 字节对齐●字节对齐练习字节对齐是一个很隐含的概念，平时可能你没有留意，但是如果你在编写网络通讯程序或者用结构去操作文件或硬件通讯结构，这个问题就会浮出水面。
我记得第一次导致我去看字节对齐概念资料的原因就是ARP通讯，ARP包头是一个31Byte包头。
当你用一个认为是31Byte结构去处理数据包时，却总是处理不对。
这一篇文章详细讨论了字节对齐要领和各种情况.字节对齐概念●现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但为了CPU访问数据的快速,通常都要求数据存放的地址是有一定规律的.●比如在32位CPU上,一般要求变量地址都是基于4位,这样可以保证CPU用一次的读写周期就可以读取变量.不按4位对齐,如果变量刚好跨4位编码,这样需要CPU两个读写周期.效率自然低下.因此,在现代的编译器都会自动把复合数据定义按4位对齐,以保证CPU以最快速度读取,这就是字节对齐(byte Alignment)产生的背景●字节对齐是一种典型,以空间换时间的策略的,在现代计算机拥有较大的内存的情况,这个策略是相当成功的.为什么要字节对齐?●加快程序访问速度●很多CPU对访问地址有严格要求,这时编译器必须要这个CPU的规范来实现,X86较为宽松,不对齐结构可能只影响效率,如ARM,访问地址必须基于偶地址,MIPS和Sparc也类似,这样不对齐的地址访问会造成错误.关于字节对齐的实现在不同的CPU对地址对齐有不同要求,各个编译器也会采用不同策略来实现字节对齐,在随后的例子,可以对比PC下的Windows,和Linux,以有ARM下的字节对齐策略.字节对齐带来的问题字节对齐相当于编译器自已在开发者定义的结构里偷偷加入一些填充字符,而且各种编译器填充的策略不一定相同.因此,在网络传输,二进制文件处理以及.底层总线传输和底层数据等相关领域,忽略字节对齐会带来严重问题.这样会产生错位使用程序处理数据完全错误.因此,网络以及硬件相关开发人员必须对字节对齐要有清晰的了解.字节对齐测试offsetof 操作符在分析字节对齐之前,首先了解一下offsetof宏.这个宏是标准C的定义,每个C库均会在stddef.h中定义.作用是计算结构或联合每一个成员的偏移量.用offsetof我们可以很清晰看到字节是如何对齐的.它的用法如下:typedef struct { char c1; int i1; char c2; } S3;printf(“c1 offset=%d,i1 offset =%d,c2 offset=%d/n”,offsetof(S3,c1),offsetof(S3,i1),offsetof(S3,c2));offsetof在不同操作系统下定成不同形式./* Keil 8051 */#define offsetof(s,m) (size_t)&(((s *)0)->m)/* Microsoft x86 */#ifdef _WIN64#define offsetof(s,m) (size_t)( (ptrdiff_t)&( ( (s *)0 )->m ) )#else#define offsetof(s,m) (size_t)&( ( (s *) 0 )->m )#endif/* Motorola coldfire */#define offsetof(s,memb) ((size_t)((char *)&((s *)0)->memb-(char *)0))/* GNU GCC 4.0.2 */#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)注意:offsetof 不能求位域成员的偏移量,offsetof 虽然引用了一个空指针来操作成员,但是由于只是在取类型,并且这个值在编译期就被确定,所以编译器在编译会直接算出offsetof的值,而不会在运行期引起内存段错误.以下我们用offsetof来分析结构和字节对齐缺省情况的字节对齐从测试结果可以看出,编译器并没有紧密的把各个数据结构排列在一起,而是按其对齐地址进行分配结构的字节对齐例1:typedef struct s2{int a;short b;char c;}s2;printf("s2 size=%d,int a=%d,short b=%d,char c=%d/n",sizeof(s2),offsetof(s2,a),offsetof(s2,b),offsetof(s2,c));测试结果是s2 size=8,int a=0,short b=4,char c=6从结果看.是总尺寸是8,各成员尺寸之和是7,从偏移量可以看在最后补齐一个字符,这是按规则4,总尺寸是最大成员倍数例2:typedef struct s5{int a;char b;short c;}s5;printf("s5 size=%d,int a=%d,char b=%d,short c=%d/n",sizeof(s5),offsetof(s5,a),offsetof(s5,b),offsetof(s5,c));测试结果是s5 size=8,int a=0,char b=4,short c=6这一次补齐的目的是为了short 型的c基于2对齐,应用第3条规则例3:typedef struct s10{char b;int a;short c;}s10;printf("s10 size=%d,char b=%d,int a=%d,short c=%d/n",sizeof(s10),offsetof(s10,b),offsetof(s10,a),offsetof(s10,c));测试结果: s10 size=12,char b=0,int a=4,short c=8第一次补齐的目的是为了int 型的a基于4对齐,应用第3条规则第二次补齐为了合符第4条规则.要为int的倍数.例5:typedef struct s4{char a;short b;char c;}s4;printf("s4 size=%d,int a=%d,short b=%d,char c=%d/n",sizeof(s4),offsetof(s4,a),offsetof(s4,b),offsetof(s4,c));测试结果: s4 size=6,int a=0,short b=2,char c=4这里最大尺寸的成员是short b所以总尺寸是2的倍数,而且short本身也需要2对齐,因此在两个不同地方补了一个byte double型的字节对齐先看测试样例typedef struct s1{char a;double b;short c;}s1;printf("s1 size=%d,char a=%d,double b=%d,short c=%d/n",sizeof(s1),offsetof(s1,a),offsetof(s1,b),offsetof(s1,c));在Windows +VC 6.0下测试结果: s1 size=24,char a=0,double b=8,short c=16在Redhat 9.0 +gcc 3.2.2下测试结果: s1 size=16,char a=0,double b=4,short c=12可以看到在两个编译器上,对double的对齐处理不一样.在Linux下,double 采用是基于4对齐.而Windows采用8对齐.再看一个实例typedef struct s1{char a;double b;char c;int d;}s1;printf("s6 size=%d,char a=%d,double b=%d,char c=%d int d=%d/n",sizeof(s6),offsetof(s6,a),offsetof(s6,b),offsetof(s6,c),offsetof(s6,d));在Windows +VC 6.0下测试结果: s6 size=24,char a=0,double b=8,char c=16 int d=20在Redhat 9.0 +gcc 3.2.2下测试结果: s6 size=20,char a=0,double b=4,char c=12 int d=16改变字节对齐设置默认的字节对齐都是按最大成员尺寸来进行对齐,但是在开发中可能需要调整对齐宽度.最常的一种情况是,在在网络和底层传输中取消字节对齐,完成按原始尺寸紧密的排列.还有一种情况是扩大或缩少字节对齐的排列.这种情况比较复杂.但应用比较少.取消字节对齐在文件处理,网络和底层传输中,数据都是紧密排列.不希望编译器在结构内部自行增加空间.这时需要开发者通知编译器,某一些结构是不需要字节对齐的.绝大部分编译器是使用预编译指令pragma取消对齐●#pragma pack (n) 设置对齐宽度为n,它可以是1,2,4,8等等,其中1就表示不进行字节对齐.⏹# pragma pack (n)是成片生效的,即在这个指令后面所有结构都会按新的对齐值进行对齐●# pragma pack()将上一次# pragma pack (n)的设置取消.恢复为默认值.●两者是成对使用,在这两者之间所有结构均受到影响注意是pragma,不是progma例子:#pragma pack(1)typedef struct s7{int a;short b;char c;}s7;#pragma pack()printf("s7 size=%d,int a=%d,short b=%d,char c=%d/n",sizeof(s7),offsetof(s7,a),offsetof(s7,b),offsetof(s7,c));测试结果s7 size=7,int a=0,short b=4,char c=6可以看到,取消字节对齐,sizeof()就成员尺寸之和.改变字节对齐这种情况比较复杂,而且也不常用.也是通过#pragma pack(n)来完成生效,但是要注意,字节对齐值采用n和默认对齐值中较小的一个.换句话说,扩大对齐值是不生效的.#pragma pack还有其它功能●#pragma pack(push) // 将当前pack设置压栈保存●#pragma pack(pop) // 恢复先前的pack设置这两个功能用于多种对齐值混用的场合,(当然,这种情况也是非常少见)缩小例子:#pragma pack (2) /*指定按2字节对齐,缺省是4 */typedef struct s8{char a;int b;short c;}s8;#pragma pack ()printf("s8 size=%d,char a=%d,int b=%d,short c=%d/n",sizeof(s8),offsetof(s8,a),offsetof(s8,b),offsetof(s8,c));测试结果: s8 size=8,char a=0,int b=2,short c=6缺省的4字节对齐话,sizoef应该是12,现在改为2对齐的话,只能是8,即在char a 补了一个字节.扩大的例子:#pragma pack (8) /*指定按2字节对齐,缺省是4 */typedef struct s9{char a;int b;short c;}s9;#pragma pack ()printf("s9 size=%d,char a=%d,int b=%d,short c=%d/n",sizeof(s9),offsetof(s9,a),offsetof(s9,b),offsetof(s9,c));测试结果:s9 size=12,char a=0,int b=4,short c=8这个结果跟4对齐是一样的,换句话说,8对齐没有生效不同环境下的字节对齐使用GCC的字节对齐控制GCC也支持#pragma 字节控制●#pragma pack (n)，gcc将按照n个字节对齐●#pragma pack ()，取消自定义字节对齐方式#pragma 只保证的成员相关偏移量是字节对齐的.不保证绝对地址对齐.GCC也支持某个一个数据结构实现绝对地址的自然对齐__attribute((aligned (n))) 让所作用的结构成员对齐在n字节自然边界上。