当前位置：文档之家 › 内存对齐及sizeof总结

内存对齐及sizeof总结

  • 格式：doc
  • 大小：65.50 KB
  • 文档页数：7

1,常用类型 sizeof() 字节数 说明

char 1 short, unsigned short, short int 2 int, unsingned int 4 float 4 double 8 long double 8 char *, int *, float *, double *, void *, char ** 4 指针类型大小固定

为4 实例： char *ss1 = "0123456789"; char ss2[] = "0123456789"; char ss3[100] = "0123456789"; int ss4[100]; char *str1 = new char[100]; int *str2 = new int[100]; 输出 cout<<"ss1 = "< cout<<"ss2 = "< //包含最后一个'\0' 11 cout<<"ss3 = "< cout<<"ss4 = "< cout<<"str1 = "< cout<<"str2 = "<

2，内存对齐 对于大部分程序员来说，“内存对齐”是“透明的”，“内存对齐”应该是编译器的“管辖范围”。编译器把程序中的每个“数据单元”安排在适当的位置。C语言的灵活性允许你干预“内存对齐”。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。 内存对齐原因： 1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

首先，ANSI C保证结构体中各字段在内存中出现的位置是随它们的声明顺序依次递增的，并且第一个字段的首地址等于整个结构体实例的首地址。比如有这样一个结构体： struct vector{int x,y,z;} s; int *p,*q,*r; struct vector *ps;

p = &s.x; q = &s.y; r = &s.z; ps = &s; assert(p < q); assert(p < r); assert(q < r); assert((int*)ps == p); // 上述断言一定不会失败 许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。当一种类型S的对齐模数与另一种类型T的对齐模数的比值是大于1的整数，我们就称类型S的对齐要求比T强(严格)，而称T比S弱(宽松)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。某些处理器在数据不满足对齐要求的情况下可能会出错，但是Intel的IA32架构的处理器则不管数据是否对齐都能正确工作。不过Intel奉劝大家，如果想提升性能，那么所有的程序数据都应该尽可能地对齐。Win32平台下的微软C编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小，即sizeof(T)。比如对于double类型(8字节)，就要求该类型数据的地址总是8的倍数，而char类型数据(1字节)则可以从任何一个地址开始。Linux下的GCC奉行的是另外一套规则(在资料中查得，并未验证，如错误请指正):任何2字节大小(包括单字节吗?)的数据类型(比如short)的对齐模数是2，而其它所有超过2字节的数据类型(比如long,double)都以4为对齐模数。 ANSI C规定一种结构类型的大小是它所有字段的大小以及字段之间或字段尾部的填充区大小之和。填充区是为了使结构体字段满足内存对齐要求而额外分配给结构体的空间。那么结构体本身有什么对齐要求吗？有的，ANSI C标准规定结构体类型的对齐要求不能比它所有字段中要求最严格的那个宽松，可以更严格(但此非强制要求，VC7.1就仅仅是让它们一样严格)。我们来看一个例子(以下所有试验的环境是Intel Celeron 2.4G + WIN2000 PRO + vc7.1，内存对齐编译选项是"默认"，即不指定/Zp与/pack选项): typedef struct ms1 { char a; int b; } MS1; 假设MS1按如下方式内存布局(本文所有示意图中的内存地址从左至右递增): _____________________________ | | | | a | b | | | | +---------------------------+ Bytes: 1 4 因为MS1中有最强对齐要求的是b字段(int)，所以根据编译器的对齐规则以及ANSI C标准，MS1对象的首地址一定是4(int类型的对齐模数)的倍数。那么上述内存布局中的b字段能满足int类型的对齐要求吗？嗯，当然不能。如果你是编译器，你会如何巧妙安排来满足CPU的癖好呢？呵呵，经过1毫秒的艰苦思考，你一定得出了如下的方案： _______________________________________ | |\\\\\\\\\\\| | | a |\\padding\\| b | | |\\\\\\\\\\\| | +-------------------------------------+ Bytes: 1 3 4 这个方案在a与b之间多分配了3个填充(padding)字节，这样当整个struct对象首地址满足4字节的对齐要求时，b字段也一定能满足int型的4字节对齐规定。那么sizeof(MS1)显然就应该是8，而b字段相对于结构体首地址的偏移就是4。非常好理解，对吗？现在我们把MS1中的字段交换一下顺序: typedef struct ms2 { int a; char b; } MS2; 或许你认为MS2比MS1的情况要简单，它的布局应该就是 _______________________ | | | | a | b | | | | +---------------------+ Bytes: 4 1 因为MS2对象同样要满足4字节对齐规定，而此时a的地址与结构体的首地址相等，所以它一定也是4字节对齐。嗯，分析得有道理，可是却不全面。让我们来考虑一下定义一个MS2类型的数组会出现什么问题。C标准保证，任何类型(包括自定义结构类型)的数组所占空间的大小一定等于一个单独的该类型数据的大小乘以数组元素的个数。换句话说，数组各元素之间不会有空隙。按照上面的方案，一个MS2数组array的布局就是: |<- array[1] ->|<- array[2] ->|<- array[3] ..... __________________________________________________________ | | | | | | a | b | a | b |............. | | | | | +---------------------------------------------------------- Bytes: 4 1 4 1 当数组首地址是4字节对齐时，array[1].a也是4字节对齐，可是array[2].a呢？array[3].a ....呢？可见这种方案在定义结构体数组时无法让数组中所有元素的字段都满足对齐规定，必须修改成如下形式: ___________________________________ | | |\\\\\\\\\\\| | a | b |\\padding\\| | | |\\\\\\\\\\\| +---------------------------------+ Bytes: 4 1 3 现在无论是定义一个单独的MS2变量还是MS2数组，均能保证所有元素的所有字段都满足对齐规定。那么sizeof(MS2)仍然是8，而a的偏移为0，b的偏移是4。 好的，现在你已经掌握了结构体内存布局的基本准则，尝试分析一个稍微复杂点的类型吧。 typedef struct ms3 { char a; short b; double c; } MS3; 我想你一定能得出如下正确的布局图:

padding | _____v_________________________________ | |\| |\\\\\\\\\| | | a |\| b |\padding\| c | | |\| |\\\\\\\\\| | +-------------------------------------+ Bytes: 1 1 2 4 8

sizeof(short)等于2，b字段应从偶数地址开始，所以a的后面填充一个字节，而sizeof(double)等于8，c字段要从8倍数地址开始，前面的a、b字段加上填充字节已经有4 bytes，所以b后面再填充4个字节就可以保证c字段的对齐要求了。sizeof(MS3)等于16，b的偏移是2，c的偏移是8。接着看看结构体中字段还是结构类型的情况: typedef struct ms4 { char a; MS3 b; } MS4; MS3中内存要求最严格的字段是c，那么MS3类型数据的对齐模数就与double的一致(为8)，a字段后面应填充7个字节，因此MS4的布局应该是: _______________________________________ | |\\\\\\\\\\\| | | a |\\padding\\| b | | |\\\\\\\\\\\| | +-------------------------------------+ Bytes: 1 7 16 显然，sizeof(MS4)等于24，b的偏移等于8。 在实际开发中，我们可以通过指定/Zp编译选项来更改编译器的对齐规则。比如指定/Zpn(VC7.1中n可以是1、2、4、8、16)就是告诉编译器最大对齐模数是n。在这种情况下，所有小于等于n字节的基本数据类型的对齐规则与默认的一样，但是大于n个字节的数据类型的对齐模数被限制为n。事实上，VC7.1的默认对齐选项就相当于/Zp8。仔细看看MSDN对这个选项的描述，会发现它郑重告诫了程序员不要在MIPS和Alpha平台上用/Zp1和/Zp2

合集下载

c++ 内存对齐规则

c++ 内存对齐规则

c++ 内存对齐规则
C++中的内存对齐规则确保数据结构在内存中按照特定的规则进行布局，以便提高访问效率和系统性能。

下面是关于C++内存对齐的详细介绍：
一、内存对齐原则：
1．对于任何给定的数据类型，其起始地址必须是它自身大小的整数倍。

2．结构体的总大小必须是其最大成员大小的整数倍。

二、默认对齐：
1．基本数据类型（如char、int、float等）的默认对齐值通常等于其大小。

2．对于结构体，其默认对齐值等于其最大成员大小。

三、结构体对齐规则：
1．结构体的对齐值为结构体中最大成员的大小。

2．结构体的大小为结构体中所有成员大小的总和，但不会小于其对齐值。

3．如果结构体中包含成员的自定义对齐指令（如#pragma pack），则按照指令指定的对齐方式进行对齐。

四、对齐修饰符：
1．C++11引入了对齐修饰符alignas，可以用于指定特定变量或结构体的对齐方式。

2．例如：alignas(8) int array[16];将array数组的对齐方式设置为8字节。

五、注意事项：
1．内存对齐可以提高访问效率，但可能会浪费一些内存空间。

2．对于跨平台开发，需要注意不同平台上的对齐规则可能不同，因此在进行数据传输或持久化存储时需要考虑跨平台兼容性。

总之，C++的内存对齐规则确保了数据在内存中按照特定规则进行布局，以提高访问效率和系统性能。

开发者可以使用默认对齐规则或使用对齐修饰符来指定特定变量或结构体的对齐方式。

内存对齐详解CC++内存对齐

内存对齐详解CC++内存对齐

内存对齐详解CC++内存对齐⼀、什么是字节对齐,为什么要对齐?现代计算机中内存空间都是按照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位系统)。

sizeof()用法汇总

sizeof()用法汇总

sizeof()功能：计算数据空间的字节数1.与strlen()比较strlen()计算字符数组的字符数，以"\0"为结束判断，不计算为'\0'的数组元素。

而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。

2.指针与静态数组的sizeof操作指针均可看为变量类型的一种。

所有指针变量的sizeof 操作结果均为4。

注意：int *p; sizeof(p)=4;但sizeof(*p)相当于sizeof(int);对于静态数组，sizeof可直接计算数组大小；例：int a[10];char b[]="hello";sizeof(a)等于4*10=40;sizeof(b)等于6;注意：数组做形参时，数组名称当作指针使用！！void fun(char p[]){sizeof(p)等于4}经典问题：double* (*a)[3][6];cout<<sizeof(a)<<endl; // 4 a为指针cout<<sizeof(*a)<<endl; // 72 *a为一个有3*6个指针元素的数组cout<<sizeof(**a)<<endl; // 24 **a为数组一维的6个指针cout<<sizeof(***a)<<endl; // 4 ***a为一维的第一个指针cout<<sizeof(****a)<<endl; // 8 ****a为一个double变量问题解析：a是一个很奇怪的定义，他表示一个指向double*[3][6]类型数组的指针。

既然是指针，所以si zeof(a)就是4。

既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此size of(*a)=3*6*sizeof(double*)=72。

内存对齐的技巧

内存对齐的技巧

内存对齐的技巧
内存对齐是一种优化技术，它可以提高数据在内存中的访问速度，减少内存访问的时间。

下面是一些内存对齐的技巧：
1. 使用对齐的数据类型：在定义结构体时，使用对齐的数据类型，例如使用32位机器上的32位整数，而不是16位整数。

2. 将大的数据类型放在前面：在定义结构体时，将大的数据类型放在前面，这样可以最大程度地减少内存碎片。

3. 使用字节对齐指令：一些编程语言和编译器提供了字节对齐的指令，可以在编译时对结构体进行字节对齐。

4. 使用特定的编译选项：在编译程序时，可以设置特定的编译选项，例如使用-malign-double选项来告诉编译器以双字对齐浮点数。

5. 避免结构体的嵌套：结构体的嵌套会增加内存的存取时间，可以尽量避免结构体的嵌套使用。

6. 了解特定平台的对齐规则：不同的平台有不同的对齐规则，了解特定平台的对齐规则可以帮助进行更好的内存对齐。

这些技巧可以帮助程序员优化内存对齐，提高程序的性能和执行效率。