内存对齐小解

本次试验是在32位系统下进行的。

一、什么是内存对齐

现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定变量的时候经常在特定的内存地址访问,这就需要各类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。

为什么要了解内存对齐:各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。其他平台可能没有这种情况,但是最常见的是如果不按照适合其平台要求对数据存放进行对齐,会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始,如果一个int型(假设为32位系统)如果存放在偶地址开始的地方,那么一个读周期就可以读出,而如果存放在奇地址开始的地方,就可能会需要2个读周期,并对两次读出的结果的高低字节进行拼凑才能得到该int数据。显然在读取效率上下降很多。这也是空间和时间的博弈。

  通常我们不需要去主动进行内存对齐的操作,编译器会自动为我们选择最优的对齐规则方式,合理利用空间节省程序运行的时间,但若是我们能了解这种规则,对于我们编写程序还是会有很大的帮助的。

二、对齐内存规则

  1.第一个成员在与结构体变量偏移量为0的地址处。

  2.其他成员变量要对齐到对齐数(编译器默认的一个对齐数与该成员大小的较小值)的整数倍的地址处。

  3.结构体总大小为最大对齐数(除了第一个成员每个成员变量都有一个对齐数)的整数倍。

  4.如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

三、实例解释

要想要看出数据的对齐方式,首先你就得明白各种数据类型在各种操作系统下所占字节的大小。

我们来看一下在32位系统下各种参数类型所占字节的大小:

接着我们用几个例子来讲解对齐规则:

(1)

首先我们用一字节对齐的方式来检验我们之前所说的类型所占字节大小:

 1 #pragma pack(1)//让编译器对此结构体作字节对齐
 2 struct A
 3 {
 4         char a;//  1
 5         int b;//   4
 6         short c;// 2
 7         long d;//  4
 8         float e;// 4
 9 };
10 #pragma pack()//取消字节对齐,回复默认字节对齐
11 int main()
12 {
13         struct A a;
14         printf("%d\n",sizeof(a));
15         return 0;
16 }

如果没有字节对齐(或者为一字节对齐方式),按照我们之前的计算方式,1+4+2+4+4=15,所占字节大小应该为15。

程序运行:

(2)我们取消之前的设置,直接使用默认对齐数对齐。

 1 #include <stdio.h>
 2 //#pragma pack(1)//让编译器对此结构体作字节对齐
 3 struct A
 4 {
 5         char a;//  1
 6         int b;//   4
 7         short c;// 2
 8         long d;//  4
 9         float e;// 4
10 };
11 //#pragma pack()//取消字节对齐,回复默认字节对齐
12 int main()
13 {
14         struct A a;
15         printf("%d\n",sizeof(a));
16         return 0;
17 }

程序运行:

由上图可以看到,明明是一样的程序,只不过取消了1字节对齐,就由原来的占15字节变成了占20字节,这就是字节对齐的原因。

我们用一张图来解释:

  第一个成员char一开始占用的是0偏移处,占用一个字节位,但由于是4字节对齐,且第二个成员int占用的字节位4,在4字节对齐的规则下,char后面只有三个字节空位,不足以放下,所以在三偏移处另开一个空存放,第三个成员short占用2字节,可以放入,第四个成员long和第五个成员float依照前面的规则正好存放20个字节,20个字节正好为这个结构体的最大对齐数的整数倍,所以这个结构体占用空间为20字节。

(3)前面我们说的都是刚好的情况,有些朋友可能还是不能很好的理解这个规则,我们再举几个例子:

 1 #include <stdio.h>
 2 //#pragma pack(1)//让编译器对此结构体作字节对齐
 3 struct A
 4 {
 5         char a;//  1
 6         int b;//   4
 7         short c;// 2
 8         //long d;//  4
 9         //float e;// 4
10 };
11 //#pragma pack()//取消字节对齐,回复默认字节对齐
12 int main()
13 {
14         struct A a;
15         printf("%d\n",sizeof(a));
16         return 0;
17 }

程序运行:

  char、int、short按一字节方式为7,但是结构体对齐之后为12,按照我们在(2)中将的方式:char占0偏移处,一字节;int在插入之后放不下,所以另起一个整数倍空间,在3偏移处,占4字节;short在7偏移处,占2字节。总共占10字节,但按照我们之前讲的,整个结构体的大小应该为最大偏移数的整数倍,所以最小整数倍应该为12,所以整个结构体占12字节。

(4)如果不信,我们可以在来变化一下结构体内数据验证

 1 #include <stdio.h>
 2 //#pragma pack(1)//让编译器对此结构体作字节对齐
 3 struct A
 4 {
 5         char a;//  1
 6         //int b;//   4
 7         short c;// 2
 8         long d;//  4
 9         char g;//  1
10         //float e;// 4
11 };
12 //#pragma pack()//取消字节对齐,回复默认字节对齐
13 int main()
14 {
15         struct A a;
16         printf("%d\n",sizeof(a));
17         return 0;
18 }

程序运行:

  char在0偏移处,占一字节,short为2字节,在最大偏移数的范围内能存下,所以在1偏移处占2字节,long在3偏移处占4字节,char在7偏移处占1字节,总共占9字节,按照对齐规则,总大小应该为4的整数倍,所以总大小为12。

四、对齐原因

  1.平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。

  2.性能原因:数据结构(尤其是栈)应该尽可能地访问在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。

五、内存对齐的好处

你知道了内存对齐的规则那么我们在编写程序的时候就能编写出更加有效高效的程序。

用一个例子来简单的解释一下:

 1 #include <stdio.h>
 2
 3 struct A
 4 {
 5         char a;
 6         int b;
 7         short c;
 8 };
 9 struct B
10 {
11         char a;
12         short b;
13         int c;
14 };
15 int main()
16 {
17         struct A a;
18         struct B b;
19         printf("%d\n",sizeof(a));
20         printf("%d\n",sizeof(b));
21         return 0;
22 }

程序运行:

结构体内成员都一样但是排列方式不一样,结构体的占用空间不一样。

用两张图就可以简单解释:

时间: 2024-09-30 02:10:12

内存对齐小解的相关文章

内存对齐与自定义类型

一.内存对齐 (一).为什么会有内存对齐? 1.为了提高程序的性能,数据结构(尤其是栈)应该尽可能的在自然边界上对齐.原因是为了访问未对齐的内存,处理器需要进行两次访问,而访问对齐的内存,只需要一次就够了.这种方式称作"以空间换时间"在很多对时间复杂度有要求问题中,会采用这种方法. 2.内存对齐能够增加程序的可移植性,因为不是所有的平台都能随意的访问内存,有些平台只能在特定的地址处处读取内存. 一般情况下内存对齐是编译器的事情,我们不需要考虑,但有些问题还是需要考虑的,毕竟c/c++是

内存对齐,大端字节 &nbsp; 序小端字节序验证

空结构体:对于空结构体,就是只有结构体这个模子,但里面却没有元素的结构体. 例: typedef struct student { }std: 这种空结构体的模子占一个字节,sizeof(std)=1. 柔性数组: 结构体中最后一个元素可以是一个大小未知的数组,称作柔性数组成员,规定柔性数组前面至少有一个元素. typedef struct student { int i; char arr[];     //柔性数组成员 }std: sizeof(std)=4; sizeof求取该结构体大小是

20160402_C++中的内存对齐

原题: 有一个如下的结构体: struct A{  long a1;  short a2;  int a3;  int *a4; }; 请问在64位编译器下用sizeof(struct A)计算出的大小是多少? 答案:24 -------------------------------------------------------------------------------- 本题知识点:C/C++ 预备知识:基本类型占用字节 在32位操作系统和64位操作系统上,基本数据类型分别占多少字节

内存对齐

有虚函数的话就有虚表,虚表保存虚函数地址,一个地址占用的长度根据编译器不同有可能不同,vs里面是8个字节,在devc++里面是4个字节.类和结构体的对齐方式相同,有两条规则1.数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中,比较小的那个进行.2.结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐,对齐将按照

内存对齐和大小端

一.内存对齐的原因 根本原因:cpu是根据内存访问粒度(memory access granularity,下文简写成MAG)来读取内存,MAG就是cpu一次内存访问操作的数据量,具体数值依赖于特定的平台,一般是2byte.4byte.8byte. 内存对齐:更够减少内存读取次数(相对于内存不对齐),为了访问未对齐的内存,处理器需要作两次内存访问:而对齐的内存访问仅需要一次访问. 二.内存对齐的步骤 每个平台上的编译器都有自己的默认“对齐系数”.同时,我们也可以通过预编译命令#pragma pa

关于内存对齐的那些事

Wrote by mutouyun. (http://darkc.at/about-data-structure-alignment/) 1. 内存对齐(Data Structure Alignment)是什么 内存对齐,或者说字节对齐,是一个数据类型所能存放的内存地址的属性(Alignment is a property of a memory address). 这个属性是一个无符号整数,并且这个整数必须是2的N次方(1.2.4.8.--.1024.--). 当我们说,一个数据类型的内存对齐

c++编程思想(三)--c++中c 续,重点sizeof和内存对齐

之前理论性的太多,下面就是代码及理论结合了 1.sizeof()是一个独立运算符,并不是函数,可以让我们知道任何变量字节数,可以顺带学一下struct,union,内存对齐 内存对齐:为了机器指令快速指向地址值,编译器内部实际上会内存对齐,怎么理解了,以struct为例 先讲一下各个变量类型内存大小 所以struct理论上是:1+2+4+4+4+8+8 = 31,但是实际是 实际大小是32(1+2+1+4)+(4+4)+8+8 然后再把int和short位置调换 实际大小是40   (1+3)+

struct内存对齐1:gcc与VC的差别

struct内存对齐:gcc与VC的差别 内存对齐是编译器为了便于CPU快速访问而采用的一项技术,对于不同的编译器有不同的处理方法. Win32平台下的微软VC编译器在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小,即sizeof(T).比如对于double类型(8字节),就要求该类型数据的地址总是8的倍数,而char类型数据(1字节)则可以从任何一个地址开始.Linux下的GCC奉行的是另外一套规则:任何2字节大小(包括单字节吗?)的数据类型(比如short)的对齐模

c++中类对象的内存对齐

很多C++书籍中都介绍过,一个Class对象需要占用多大的内存空间.最权威的结论是: *非静态成员变量总合.(not static) *加上编译器为了CPU计算,作出的数据对齐处理.(c语言中面试中经常会碰到内存对齐的问题) *加上为了支持虚函数(virtual function),产生的额外负担. 下面给出几个程序来看一下: #include <iostream> #include <cstdio> #include <string> using namespace