字节对齐
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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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字节自然边界上。