C语言内存对齐
分类：C/C++2012-04-05 20:54 1070人阅读评论(1) 收藏举报语言c编译器平台oo
首先由一个程序引入话题：
1//环境：vc6 + windows sp2
2//程序1
3 #include
4
5using namespace std;
6
7struct st1
8 {
9char a ;
10int b ;
11short c ;
12 };
13
14struct st2
15 {
16short c ;
17char a ;
18int b ;
19 };
20
21int main()
22 {
23 cout<<"sizeof(st1) is "< 24 cout<<"sizeof(st2) is "< 25return 0 ; 26 } 27 程序的输出结果为： sizeof(st1) is 12 sizeof(st2) is 8 问题出来了，这两个一样的结构体，为什么sizeof的时候大小不一样呢？ 本文的主要目的就是解释明白这一问题。 内存对齐，正是因为内存对齐的影响，导致结果不同。 对于大多数的程序员来说，内存对齐基本上是透明的，这是编译器该干的活，编译器为程序中的每个数据单元安排在合适的位置上，从而导致了相同的变量，不同声明顺序的结构体大小的不同。 那么编译器为什么要进行内存对齐呢？程序1中结构体按常理来理解sizeof(st1)和sizeof(st2)结果都应该是7，4(int) + 2(short) + 1(char) = 7 。经过内存对齐后，结构体的空间反而增大了。 在解释内存对齐的作用前，先来看下内存对齐的规则： 1、对于结构的各个成员，第一个成员位于偏移为0的位置，以后每个数据成员的偏移量必须是min(#pragma pack()指定的数，这个数据成员的自身长度) 的倍数。 2、在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 #pragma pack(n) 表示设置为n字节对齐。VC6默认8字节对齐 以程序1为例解释对齐的规则： St1 ：char占一个字节，起始偏移为0 ，int 占4个字节，min(#pragmapack()指定的数，这个数据成员的自身长度) = 4（VC6默认8字节对齐），所以int按4字节对齐，起始偏移必须为4的倍数，所以起始偏移为4，在char后编译器会添加3个字节的额外字节，不存放任意数据。short占2个字节，按2字节对齐，起始偏移为8，正好是2的倍数，无须添加额外字节。到此规则1的数据成员对齐结束，此时的内存状态为： oxxx|oooo|oo 0123 4567 89 （地址） （x表示额外添加的字节） 共占10个字节。还要继续进行结构本身的对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行，st1结构中最大数据成员长度为int，占4字节，而默认的#pragma pack 指定的值为8，所以结果本身按照4字节对齐，结构总大小必须为4的倍数，需添加2个额外字节使结构的总大小为12 。此时的内存状态为： oxxx|oooo|ooxx 0123 4567 89ab （地址） 到此内存对齐结束。St1占用了12个字节而非7个字节。 St2 的对齐方法和st1相同，读者可自己完成。 内存对齐的主要作用是： 1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 2、性能原因：经过内存对齐后，CPU的内存访问速度大大提升。具体原因稍后解释。 图一： 这是普通程序员心目中的内存印象，由一个个的字节组成，而CPU并不是这么看待的。 图二： CPU把内存当成是一块一块的，块的大小可以是2，4，8，16字节大小，因此CPU在读取内存时是一块一块进行读取的。块大小成为memory accessgranularity（粒度）本人把它翻译为“内存读取粒度”。 假设CPU要读取一个int型4字节大小的数据到寄存器中，分两种情况讨论： 1、数据从0字节开始 2、数据从1字节开始 再次假设内存读取粒度为4。 图三： 当该数据是从0字节开始时，很CPU只需读取内存一次即可把这4字节的数据完全读取到寄存器中。 当该数据是从1字节开始时，问题变的有些复杂，此时该int型数据不是位于内存读取边界上，这就是一类内存未对齐的数据。 图四： 此时CPU先访问一次内存，读取0—3字节的数据进寄存器，并再次读取4—5字节的数据进寄存器，接着把0字节和6，7，8字节的数据剔除，最后合并1，2，3，4字节的数据进寄存器。对一个内存未对齐的数据进行了这么多额外的操作，大大降低了CPU性能。 这还属于乐观情况了，上文提到内存对齐的作用之一为平台的移植原因，因为以上操作只有有部分CPU肯干，其他一部分CPU遇到未对齐边界就直接罢工了。 对齐方式 为什么会有内存对齐？ 在结构中，编译器为结构的每个成员按其自然对界（alignment）条件分配空间；各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。在缺省情况下，C编译器为每一个变量或数据单元按其自然对界条件分配空间。 字，双字，和四字在自然边界上不需要在内存中对齐。（对字，双字，和四字来说，自然边界分别是偶数地址，可以被4整除的地址，和可以被8整除的地址。）无论如何，为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。 一个字或双字操作数跨越了4字节边界，或者一个四字操作数跨越了8字节边界，被认为是未对齐的，从而需要两次总线周期来访问内存。一个字起始地址是奇数但却没有跨越字边界被认为是对齐的，能够在一个总线周期中被访问。 某些操作双四字的指令需要内存操作数在自然边界上对齐。如果操作数没有对齐，这些指令将会产生一个通用保护异常（#GP）。双四字的自然边界是能够被16整除的地址。其他的操作双四字的指令允许未对齐的访问（不会产生通用保护异常），然而，需要额外的内存总线周期来访问内存中未对齐的数据。 影响结构体的sizeof的因素： 1）不同的系统（如32位或16位系统）：不同的系统下int等类型的长度是变化的，如对于16位系统，int的长度（字节）为2，而在32位系统下，int的长度为4；因此如果结构体中有int等类型的成员，在不同的系统中得到的sizeof值是不相同的。 2）编译器设置中的对齐方式：对齐方式的作用常常会让我们对结构体的sizeof 值感到惊讶，编译器默认都是8字节对齐。 对齐: 为了能使CPU对变量进行高效快速的访问，变量的起始地址应该具有某些特性，即所谓的“对齐”。例如对于4字节的int类型变量，其起始地址应位于4字节边界上，即起始地址能够被4整除。变量的对齐规则如下（32位系统） 1.内存字节对齐和小端模式： /* 本程序是关于：编译器内存的字节对齐方式和存储时的小端对齐模式(win7 32bit) #pragma pack(n) 默认为8字节对齐，(即n=8)其中n的取值为1,2,4,8,16,32等 内存字节对齐大小和方式： 1)结构体内变量对齐： 每个变量的对齐字节数大小argAlignsize=min(#pragma pack(n),sizeof(变量))； 方式：结构体的第一个变量的初始偏移地址为0，其它变量的偏移地址(当前变量的起始地址)必须是argAlignsize的整数倍，不够整数倍的补空，不添加任何数据 2)结构体对齐： 结构体的对齐字节数大小strAlignsize=min(#pragma pack(n),sizeof(所有变量中最大字节的变量)) 方式： A.对于单独的结构体来说，结构体本身按照strAlignsize大小来对齐 B.结构体B在结构体A中时，结构体B的起始地址是结构体B的 strAlignsize大小的整数倍 小端对齐模式： 指针指着一个存储空间，存储空间地址由低到高的存储内容为：0x78,0x67,0x33,0x45 若指针为char，则获取的数据为0x78 若指针为short，则获取的数据为0x6778 若指针为long，则获取的数据为0x45336778 */ #include sse2指令集 1移动指令: 1. Movaps movaps XMM,XMM/m128 movaps XMM/128,XMM 把源存储器内容值送入目的寄存器,当有m128时,必须对齐内存16字节,也就是内存地址低4位为0. 2. Movups movups XMM,XMM/m128 movaps XMM/128,XMM 把源存储器内容值送入目的寄存器,但不必对齐内存16字节 3. Movlps movlps XMM,m64 把源存储器64位内容送入目的寄存器低64位,高64位不变,内存变量不必对齐内存16字节4. Movhps movhps XMM,m64 把源存储器64位内容送入目的寄存器高64位,低64位不变,内存变量不必对齐内存16字节. 5. Movhlps movhlps XMM,XMM 把源寄存器高64位送入目的寄存器低64位,高64位不变. 6. Movlhps movlhps XMM,XMM 把源寄存器低64位送入目的寄存器高64位,低64位不变. 7. movss movss XMM,m32/XMM 原操作数为m32时：dest[31-00] <== m32 dest[127-32] <== 0 原操作数为XMM时: dest[31-00] <== src[31-00] dest[127-32]不变 8. movmskpd movmskpd r32,XMM 取64位操作数符号位 r32[0] <== XMM[63] r32[1] <== XMM[127] r32[31-2] <== 0 9. movmskps movmskps r32,XMM 取32位操作数符号位 r32[0] <== XMM[31] r32[1] <== XMM[63] r32[2] <== XMM[95] r32[3] <== XMM[127] r32[31-4] <== 0 10. pmovmskb pmovmskb r32,XMM 取16位操作数符号位具体操作同前 r[0] <== XMM[7] r[1] <== XMM[15] r[2] <== XMM[23] r[3] <== XMM[31] r[4] <== XMM[39] r[5] <== XMM[47] r[6] <== XMM[55] r[7] <== XMM[63] r[8] <== XMM[71] r[9] <== XMM[79] r[10] <== XMM[87] r[11] <== XMM[95] r[12] <== XMM[103] r[13] <== XMM[111] r[14] <== XMM[119] r[15] <== XMM[127] r[31-16] <== 0 11. movntps movntps m128,XMM m128 <== XMM 直接把XMM中的值送入m128，不经过cache,必须对齐16字节. 12. Movntpd movntpd m128,XMM m128 <== XMM 直接把XMM中的值送入m128，不经过cache,必须对齐16字节. 13. Movnti movnti m32,r32 m32 <== r32 把32寄存器的值送入m32，不经过cache. 14. Movapd movapd XMM,XMM/m128 movapd XMM/m128,XMM 把源存储器内容值送入目的寄存器,当有m128时,必须对齐内存16字节 15. Movupd movupd XMM,XMM/m128 movapd XMM/m128,XMM 把源存储器内容值送入目的寄存器,但不必对齐内存16字节. 我感觉这两条指令同movaps 和movups 指令一样,不过又不确定. 16. Movlpd movlpd XMM,m64 movlpd m64,XMM 把源存储器64位内容送入目的寄存器低64位,高64位不变,内存变量不必对齐内存16字节 C语言内存对齐 分类：C/C++2012-04-05 20:54 1070人阅读评论(1) 收藏举报语言c编译器平台oo 首先由一个程序引入话题： 1//环境：vc6 + windows sp2 2//程序1 3 #include 程序的输出结果为： sizeof(st1) is 12 sizeof(st2) is 8 问题出来了，这两个一样的结构体，为什么sizeof的时候大小不一样呢？ 本文的主要目的就是解释明白这一问题。 内存对齐，正是因为内存对齐的影响，导致结果不同。 对于大多数的程序员来说，内存对齐基本上是透明的，这是编译器该干的活，编译器为程序中的每个数据单元安排在合适的位置上，从而导致了相同的变量，不同声明顺序的结构体大小的不同。 那么编译器为什么要进行内存对齐呢？程序1中结构体按常理来理解sizeof(st1)和sizeof(st2)结果都应该是7，4(int) + 2(short) + 1(char) = 7 。经过内存对齐后，结构体的空间反而增大了。 在解释内存对齐的作用前，先来看下内存对齐的规则： 1、对于结构的各个成员，第一个成员位于偏移为0的位置，以后每个数据成员的偏移量必须是min(#pragma pack()指定的数，这个数据成员的自身长度) 的倍数。 2、在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 #pragma pack(n) 表示设置为n字节对齐。VC6默认8字节对齐 以程序1为例解释对齐的规则： C语言内存字节对齐规则 在C语言面试和考试中经常会遇到内存字节对齐的问题。今天就来对字节对齐的知识进行小结一下。 首先说说为什么要对齐。为了提高效率，计算机从内存中取数据是按照一个固定长度的。以32位机为例，它每次取32个位，也就是4个字节（每字节8个位，计算机基础知识，别说不知道）。字节对齐有什么好处？以int型数据为例，如果它在内存中存放的位置按4字节对齐，也就是说1个int的数据全部落在计算机一次取数的区间内，那么只需要取一次就可以了。如图a-1。如果不对齐，很不巧，这个int数据刚好跨越了取数的边界，这样就需要取两次才能把这个int的数据全部取到，这样效率也就降低了。 图：a-1 图：a-2 内存对齐是会浪费一些空间的。但是这种空间上得浪费却可以减少取数的时间。这是典型的一种以空间换时间的做法。空间与时间孰优孰略这个每个人都有自己的看法，但是C 语言既然采取了这种以空间换时间的策略，就必然有它的道理。况且，在存储器越来越便宜的今天，这一点点的空间上的浪费就不算什么了。 需要说明的是，字节对齐不同的编译器可能会采用不同的优化策略，以下以GCC为例讲解结构体的对齐. 一、原则： 1.结构体内成员按自身按自身长度自对齐。 自身长度，如char=1，short=2，int=4，double=8,。所谓自对齐，指的是该成员的起始位置的内存地址必须是它自身长度的整数倍。如int只能以0,4,8这类的地址开始 2.结构体的总大小为结构体的有效对齐值的整数倍 结构体的有效对齐值的确定： 1）当未明确指定时，以结构体中最长的成员的长度为其有效值 2）当用#pragma pack(n)指定时，以n和结构体中最长的成员的长度中较小者为其值。 3）当用__attribute__ ((__packed__))指定长度时，强制按照此值为结构体的有效对齐值 二、例子 1) struct AA{ //结构体的有效对齐值为其中最大的成员即int的长度4 char a; int b; char c; }aa 结果，sizeof（aa）=12 何解？首先假设结构体内存起始地址为0，那么地址的分布如下 0 a 1 2 3 4 b 5 b 6 b 7 b 8 c 9 10 11 char的字对齐长度为1，所以可以在任何地址开始，但是，int自对齐长度为4，必须以4的倍数地址开始。所以，尽管1-3空着，但b也只能从4开始。再加上c后，整个结构体的总长度为9，结构体的有效对齐值为其中最大的成员即int的长度4，所以，结构体的大小向上扩展到12，即9-11的地址空着。 2) //结构体的有效对齐值为其中最大的成员即int的长度4 struct AA{ char a; char c; int b; }aa sizeof（aa）=8，为什么呢 0 a 1 c 解析C语言结构体对齐(内存对齐问题) C语言结构体对齐也是老生常谈的话题了。基本上是面试题的必考题。内容虽然很基础，但一不小心就会弄错。写出一个struct，然后sizeof，你会不会经常对结果感到奇怪？sizeof的结果往往都比你声明的变量总长度要大，这是怎么回事呢？ 开始学的时候，也被此类问题困扰很久。其实相关的文章很多，感觉说清楚的不多。结构体到底怎样对齐？ 有人给对齐原则做过总结，具体在哪里看到现在已记不起来，这里引用一下前人的经验（在没有#pragma pack宏的情况下）： 原则1、数据成员对齐规则：结构（struct或联合union）的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小的整数倍开始（比如int在32位机为４字节，则要从4的整数倍地址开始存储）。 原则2、结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。（struct a里存有struct b，b里有char，int，double等元素，那b应该从8的整数倍开始存储。） 原则3、收尾工作：结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐。 这三个原则具体怎样理解呢？我们看下面几个例子，通过实例来加深理解。 例1：struct { short a1; short a2; short a3; }A; struct{ long a1; short a2; }B; sizeof(A) = 6; 这个很好理解，三个short都为2。 sizeof(B) = 8; 这个比是不是比预想的大2个字节？long为4，short为2，整个为8，因为原则3。 例2：struct A{ int a; char b; short c; }; struct B{ char b; int a; short c; }; sizeof(A) = 8; int为4，char为1，short为2，这里用到了原则1和原则3。 sizeof(B) = 12; 是否超出预想范围？char为1，int为4，short为2，怎么会是12？还是原则1和原则3。 C语言结构体对齐 C语言结构体对齐也是老生常谈的话题了。基本上是面试题的必考题。内容虽然很基础，但一不小心就会弄错。写出一个struct，然后sizeof，你会不会经常对结果感到奇怪？sizeof的结果往往都比你声明的变量总长度要大，这是怎么回事呢？ 开始学的时候，也被此类问题困扰很久。其实相关的文章很多，感觉说清楚的不多。结构体到底怎样对齐？ 有人给对齐原则做过总结，具体在哪里看到现在已记不起来，这里引用一下前人的经验（在没有#pragma pack宏的情况下）： 原则1、数据成员对齐规则：结构（struct或联合union）的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小的整数倍开始（比如int在32位机为４字节，则要从4的整数倍地址开始存储）。 原则2、结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。（struct a里存有struct b，b 里有char，int，double等元素，那b应该从8的整数倍开始存储。） 原则3、收尾工作：结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐。 这三个原则具体怎样理解呢？我们看下面几个例子，通过实例来加深理解。 例1：struct { short a1; short a2; short a3; }A; struct{ long a1; short a2; }B; sizeof(A) = 6; 这个很好理解，三个short都为2。 sizeof(B) = 8; 这个比是不是比预想的大2个字节？long为4，short为2， 内存中结构体的内存对齐 一、字节对齐作用和原因： 对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误，那么在这种架构下编程必须保证字节对齐，其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit 数据，显然在读取效率上下降很多。 二、字节对齐规则： 四个重要的概念： 1．数据类型自身的对齐值：对于char型的数据，其自身对齐值为1，对于short型为2，对于int，float，double类型，其自身对齐值为4个字节。 2．结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。 3．指定对齐值：#pragma pack (value)时指定的对齐value。 4．数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。补充： 1).每个成员分别按自己的方式对齐,并能最小化长度。 2).复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。 3).对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。 #pragma pack(1) struct test { static int a; //static var double m4; char m1; int m3; } #pragma pack() //sizeof(test)=13; 首先由一个程序引入话题： 1//环境：vc6 + windows sp2 2//程序1 3#include sizeof(st1) is 12 sizeof(st2) is 8 问题出来了，这两个一样的结构体，为什么sizeof的时候大小不一样呢？ 本文的主要目的就是解释明白这一问题。 内存对齐，正是因为内存对齐的影响，导致结果不同。 对于大多数的程序员来说，内存对齐基本上是透明的，这是编译器该干的活，编译器为程序中的每个数据单元安排在合适的位置上，从而导致了相同的变量，不同声明顺序的结构体大小的不同。 那么编译器为什么要进行内存对齐呢？程序1中结构体按常理来理解sizeof(st1)和sizeof(st2)结果都应该是7，4(int) + 2(short) + 1(char) = 7 。经过内存对齐后，结构体的空间反而增大了。 在解释内存对齐的作用前，先来看下内存对齐的规则： 1、对于结构的各个成员，第一个成员位于偏移为0的位置，以后每个数据成员的偏移量必须是min(#pragma pack()指定的数，这个数据成员的自身长度) 的倍数。 2、在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 #pragma pack(n) 表示设置为n字节对齐。VC6默认8字节对齐 以程序1为例解释对齐的规则： St1 ：char占一个字节，起始偏移为0 ，int占4个字节，min(#pragma pack()指定的数，这个数据成员的自身长度) = 4（VC6默认8字节对齐），所以int按4字节对齐，起始偏移必须为4的倍数，所以起始偏移为4，在char后编译器会添加3个字节的额外字节，不存放任意数据。short占2个字节，按2字节对齐，起始偏移为8，正好是2的倍数，无须添加额外字节。到此规则1的数据成员对齐结束，此时的内存状态为： oxxx|oooo|oo 最近被面试了，打击挺大，问啥啥不会。 举一个很多不会的题中的一个，关于内存对齐的问题，以前也知道点，个人感觉很重要，在这里与同道中人分享下： 很多书籍中都讲到：内存可以看成一个byte数组，我们通过编程语言提供的工具对这个'大数组'中的每个元素进行读写，比如在C中我们可以用指针一次读写一个或者更多个字节，这是我们一般程序员眼中的内存样子。但是从机器角度更具体的说从CPU角度看呢，CPU发出的指令是一个字节一个字节读写内存吗？答案是'否'。CPU是按照'块(chunk)'来读写内存的，块的大小可以是2bytes, 4bytes, 8bytes, 16bytes甚至是32bytes. 这个CPU访问内存采用的块的大小，我们可以称为'内存访问粒度'。 程序员眼中的内存样子： --------------------------------- | | | | | | | | | | | | | | | | | --------------------------------- 0 1 2 3 4 5 6 7 8 9 A B C D E F (地址) CPU眼中的内存样子：(以粒度＝4为例) --------------------------------------------- | | | | | | | | | | | | | | | | | | | | --------------------------------------------- 0 1 2 3 4 5 6 7 8 9 A B C D E F (地址) 有了上面的概念，我们来看看粒度对CPU访问内存的影响。 假设这里我们需要的数据分别存储于地址0和地址1起始的连续4个字节的存储器中，我们目的是分别读取这些数据到一个4字节的寄存器中， 如果'内存访问粒度'为1，CPU从地址0开始读取，需要4次访问才能将4个字节读到寄存器中； 同样如果'内存访问粒度'为1，CPU从地址1开始读取，也需要4次访问才能将4个字节读到寄存器中；而且对于这种理想中的''内存访问粒度'为1的CPU，所有地址都是'aligned address'。 如果'内存访问粒度'为2，CPU从地址0开始读取，需要2次访问才能将4个字节读到寄存器中；每次访存都能从'aligned address'起始。 如果'内存访问粒度'为2，CPU从地址1开始读取，相当于内存中数据分布在1,2,3,4三个地址上，由于1不是'aligned address'，所以这时CPU要做些其他工作，由于这四个字节分步在三个chunk上，所以CPU需要进行三次访存操作，第一次读取chunk1(即地址0,1上两个字节，而且仅仅地址1上的数据有用)，第二次读取chunk2(即地址2,3上两个字节，这两个地址上的数据都有用)，最后一次读取chunk3(即地址5,6上两个字节，而且仅仅地址5上的 C语言中内存对齐规则讨论（struct） (2012-02-17 17:51:17) 转载▼ 分类：学习 标签： struct union c语言 内存 it 对齐： 现代计算机中内存空间都是按着byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定变量的时候经常在特定的内存地址访问，这就是需要各类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。 对齐的作用： 各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存储。其他平台可能没有这种情况，但是最常见的是如果不按照合适其平台的要求对数据进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶数地址开始，如果一个int型（假设为32位）如 果存放在偶数开始的地方，那么一个读周期就可以读出，而如果存放在奇地址开始的地方，就可能会需要2个读周期，并对两次独处的结果的高低字节进行拼凑才能得到该int数据。显然在读取效率上下降很多。 对齐的实现 通常我们写程序的时候，不需要考虑对齐问题，编译器会替我们选择适合目标平台的对齐策略。当然，我们也可以通知给编译器传递预编译指令而改变对制定数据的对齐方法。缺省情况下，编译器为结构体的每个成员按其自然対界条件分配空间。各个成员按照他们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。自然対界即默认对齐方式，是指按结构体的成员中size最大的成员对齐。 最常见的就是struct数据结构的sizeof的结果出乎意料。 结构体的sizeof的值并不是简单的将其中各个元素所占的字节相加，而是要考虑到存储空间的字节对齐问题 结构体默认的字节对齐准则： 1.结构体变量的首地址能够被其最宽基本类型成员的大 小所整除； 引言：结构对齐的目的是为了加快ＣＰＵ取数据时的速度，不同的编译器有不同的标准，有关于４字节对齐的，也有关于８字节对齐的，解题时需跟据环境具体分析。 环境：ubuntu10.10 gcc 判断结构大小，只需要注意两点即可： 1.分析结构成员： 小于4字节的结构成员，相对起始地址要在成员大小的倍数上 Char 1 char 类型可以从任何地址开始 Short 2 short 类型需要相对结构起始地址以2 的倍数处开始 Int 4 大于4 4 对齐如double 大小为8字节，只需按4字节对齐即可 2.整个结构要关于最大的成员大小对齐（不大于4） 如果结构最大的成员是short 那么结构的大小应是2 的倍数，（不足时在结构末尾补足）如果最大成员是int ，则应是4 的倍数。 如果是double ，则是4 的倍数。 为什么是4 的倍数？ 这是GCC默认的对齐大小，可以修改。VC下应该默认是8。 测试，以下结构的大小是？ struct com { char c1; 1字节由下面的对齐知道占用了4 字节 long tt; 关于4 字节对齐占用了4 字节 int c9; 关于4 字节对齐占用了4 字节 short c3; 关于2 字节对齐占用了4 字节 double c4; 关于4字节对齐占用了8 字节 }; 4 的倍数，所以大小共24 字节。 struct T { char a; double b; }; struct TT { short a; char b; short aa; }; struct A char c; double d; short s; char sf[5]; }; struct B { short s; char sf[5]; char c; double d; }; struct C { char c; short s; char sf[5]; double d; }; struct D { double d; char sf[5]; short s; char c; }; struct E { char c; char sf[5]; double d; short s; }; 解析C语言中的sizeof 一、sizeof的概念 sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。 二、sizeof的使用方法 1、用于数据类型 sizeof使用形式：sizeof（type） 数据类型必须用括号括住。如sizeof（int）。 2、用于变量 sizeof使用形式：sizeof（var_name）或sizeof var_name 变量名可以不用括号括住。如sizeof (var_name)，sizeof var_name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。 注意：sizeof操作符不能用于函数类型，不完全类型或位字段。不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。 如sizeof(max)若此时变量max定义为int max(),sizeof(char_v) 若此时char_v定义为char char_v [MAX]且MAX未知，sizeof(void)都不是正确形式。 三、sizeof的结果 sizeof操作符的结果类型是size_t，它在头文件 中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。 1、若操作数具有类型char、unsigned char或signed char，其结果等于1。 ANSI C正式规定字符类型为1字节。 2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、float、double、long double类型的sizeof 在ANSI C 中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、 C语言地址对齐分析与示例 1.什么是地址对齐 计算机硬件设计的特点决定了这样一个事实：CPU在访问内存时，如果其地址是机器字长的整数倍，那么访问的效率就会比较高。这样的现象就称为地址对齐（也有说内存对齐）。并且有的CPU根本就无法访问那些地址没有对齐的内存单元（这时需要使用软件模拟地址对齐，操作效率会大为降低）。而在一般32位机上，地址对齐的界限是32/8=4的整数倍。 2.地址对齐与执行效率 为了提高程序的执行效率，编译器会努力让所有变量的地址符合地址对齐的原则。这在结构体中体现的比较明显，例如如下的结构体定义： struct S1{ char c1; char c2; char c3; int x; char c4; }; 如果我们使用sizeof关键字求该结构体的大小，就会发现sizeof(S1)并不等于其包含各域的大小之和。这本示例中sizeof(S1)=12而不是8。这是因为编译器为了使结构体中数据能够满足地址对齐而自动的加入了空闲字节。这些空闲字节没有被任何数据成员使用，它们存在的目的只是为了满足内存地址能够对齐。 我们可以用如下图解释上述现象： 4n4(n+1)4(n+2) 1111413 整个结构体【总计12字节】 如果我们将S1结构体中int x和char c4的位置互换，则sizeof(S1)就会变为8。大家可按照上述分析方法考虑其原因。 3.编译器，请不要自作主张 自动对齐的方式虽然能够提高执行效率，然而却浪费了空间（这貌似也显示了一些时空一致性的思想:)）。真是鱼和熊掌不可得兼。那么当我们在意的是空间而不是时间的时候，自动的地址对齐就不那么受欢迎了。于是我们可以采用下面的办法让编译器“老实点”。 #pragma pack(1)/*将地址对齐的界限设定为1*/ struct S1{ char c1; char c2; char c3; int x; char c4; }; 这时S1的大小就只有8个字节了（因为我们将地址对齐的界限设定为1了，当然就不再需要空闲字节去补齐内存了）。如果想在S1以后的定义中仍使用默认的对齐界限，只需在S1的定义之后加上#pragma pack()就行了。 C/C++内存对齐 一、什么是字节对齐,为什么要对齐? 现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。 对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。 二、请看下面的结构： struct MyStruct { double dda1; char dda; int type }; 对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求： sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？ 其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。 类型 对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） Char 偏移量必须为sizeof(char)即1的倍数 int 偏移量必须为sizeof(int)即4的倍数 float 偏移量必须为sizeof(float)即4的倍数 double 偏移量必须为sizeof(double)即8的倍数 Short C语言中结构体占用内存大小的问题 2014-04-22 10:55 Deng_Ran | 分类：C/C++ | 浏览381次 struct stOne // 结构体1 { char c1; int i1; char c2; int i2; }; struct stTwo // 结构体2 { char c1; char c2; int i1; int i2; }; 各位大侠，上面两个结构体因为硬件的边界调整原则，占用内存大小并不相同。在我的电脑上，sizeof(struct stOne)是16，sizeof(struct stTwo)是12。 小弟有一疑问，会不会存在一种情况: struct stOne stA, stB; // 定义两个结构体 这两个结构体大小并不相同，即同一类型结构体能否占用不同内存大小？ 分享到： 2014-04-22 11:01 提问者采纳 你好，struct stOne stA, stB; // 定义两个结构体 这两个结构体大小完全相同！！ 追问 谢谢大侠回复，小弟还有一问题请教： struct stOne { char c1; int i1; char c2; }; char类型变量的边界是1，int类型变量的边界是4，那么，我感觉这个结构体的大小是1 + (3) + 4 + 1 = 9，但实际上占用的内存是12？ 回答 是的，最后的大小就类似于一个由几根木板组成的长方形，也许每根的长度都不一样，但是都要按照最长的那根那样存放，所以占用内存= 最长的那根 X 根数 有3个变量所以 4*3 =12 其他3条回答 2014-04-22 11:03 阳顶天鹿鼎记 | 七级 不会，同一个结构体占用的内存都是一样的， stOne和stTwo之所以不同，是因为内存对齐问题。 取内存时，是按照主机系统是多少位来取的 32位系统，每次取四个字节 64位系统，每次取8个字节 根据你sizeof得到的结果，你的系统是32位的，所以每次取四个字节，而stOne char类型占用一个，而int占用四个，所以char类型自动占用了4个，否则，如果char占用一个，取得时候，去了一个char,然后去了int变量的前三个，这样会出问题，所以，会得到你上面sizeof的结果 stTwo,就不会因为是两个char类型挨着的，这样两个char类型占用四个，取得时候先取两个char，再取int。 评论 | 3 0 2014-04-22 11:04 冰血无双 | 七级 不会不同，自己查一下数据补齐、数据对齐，还有内存页的概念 评论 | 1 0 2014-04-22 11:05 ylx2193395 | 三级 这是因为字节对齐原则，在Linux下其是按2字节对齐，可是在VC++下默认是按8字节对齐，必须满足4的整数倍。这样有助于存储效率。第一个char 为1字节，int为4字节,由于8字节对齐原则系统会预留出3个字节，保证8个字节对齐。而第二个两个char 2个字节，1个int4字节，系统补充2个字节后，此时8个字节，再加一个Int为12.满足条件 1. 写出判断ABCD四个表达式是否正确，若正确，写出经过表达式中a的值(3分) int a = 4; (A) a += (a++); (B) a += (++a); (C) (a++) += a; (D) (++a) += (a++); a = ? 答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a;改后答案依次为9,10,10,11 2. 某32位系统下，C++程序，请计算sizeof的值(5分) char str[] = "ALLEN"; char *p = str; int n = 10; 请计算 (1) sizeof(str) = ？ (2) sizeof(p) = ？ (3) sizeof(n) = ？ (4) void *pp = malloc(100); sizeof(pp) = ？ 答：(1) 6 (2) 4 (3) 4 (4) 4 3. 回答下面的问题. (4分) (1) 头文件中的ifndef/define/endif干什么用？ 答：防止头文件被重复引用。 (2) ＃include ARM 内存对齐总结 一、啥是内存对齐？为啥要内存对齐？ 现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问都可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就是对齐。 字节对齐的原因大致是如下两条： 1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。 二、对齐规则 每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。规则： 1. 数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在偏移量为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行， 即各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的整数倍。 2. 结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 3. 结合1、2可推断：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n 的倍数，不用满足默认的对齐方式。 三、X86对齐实验 下面再简要回顾解释一下上述的对齐规则，结合实例进行分析： 1. 数据类型自身的对齐值：对于char型数据，其自身对齐值为1字节，对于short型为2字节，对于 int,float,double类型，其自身对齐值为4字节。 2. 结构体的自身对齐值：其成员中自身对齐值最大的那个值。 3. 指定对齐值：#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始 地址的偏移量有两种情况，第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n 的倍数，不用满足默认的对齐方式。 4. 数据成员和结构体的有效对齐值：数据成员(数据类型)和数据结构的自身对齐值和指定对齐值中小的那个值，数据成员对齐了数据结构自然也就对齐了。 了解上述四个基本概念，我们开始讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0"。而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐内存对齐方式
内存字节对齐
寄存器sse2指令集
内存对齐
C语言内存字节对齐规则20180718
C语言内存对齐
C语言结构体对齐
C语言结构体的字节对齐及指定对齐方式
内存对齐方法及原理
内存对齐
内存对齐规则
GCC下结构体内存对齐问题
内存对齐问题的完美解释
C语言内存对齐分析与示例
C++内存对齐
结构体所占内存大小(字节对齐问题)
C++笔试题(华为)
ARM 内存对齐总结
相关主题
文本预览