C语言内存对齐实例详解

本文详细讲述了C语言程序设计中内存对其的概念与用法。分享给大家供大家参考之用。具体如下:

一、字节对齐基本概念

现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。 对齐的作用和原因:各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况,但是最常见的是如果不按照适合其平台要求对数据存放进行对齐,会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始,如果一个int型(假设为32位系统)如果存放在偶地址开始的地方,那 么一个读周期就可以读出这32bit,而如果存放在奇地址开始的地方,就需要2个读周期,并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。

请看下面的结构:

struct struct1
{
  double dda;
  char cda;
  int ida;
};
sizeof(struct1) = ?

错误的求法:

sizeof(struct1)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是当你运行如下测试代码:

#include<stdio.h>
struct mystruct
{
  double dda;
  char cda;
  int ida;
};
int main()
{
  struct mystruct ss;
  printf("%d\n",sizeof(ss));
  return 0;
}

运行结果为:16

其实,这是编译器对变量存储的一个特殊处理。为了提高CPU的存储速度,编译器对一些变量的起始地址做了“对齐”处理。在默认情况下,编译器规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式:

类型            对齐方式(变量存放的起始地址相对于结构的起始地址的偏移量)

char              偏移量必须为sizeof(char)即1的倍数

int                偏移量必须为sizeof(int)即4的倍数

float             偏移量必须为sizeof(float)即4的倍数

double          偏移量必须为sizeof(double)即8的倍数

Short            偏移量必须为sizeof(short)即2的倍数

各成员变量在存放的时候根据在结构中出现的顺序依次申请空间,同时按照上面的对齐方式调整位置,空缺的字节编译器会自动填充。同时编译器为了确保结构的大小为结构的字节边界数(即该结构中占用最大空间的类型所占用的字节数)的倍数,所以在为最后一个成员变量申请空间后,还会根据需要自动填充空缺的字节

现在来分析编译器是怎样来存放结构的:

struct struct1
{
  double dda;
  char cda;
  int ida;
};

第一个成员dda分配空间,其起始地址跟结构的起始地址相同(偏移量0刚好为sizeof(double)的倍数),该成员变量占用sizeof(double)=8个字节;接下来为第二个成员cda分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为8,是sizeof(char)的倍数,所以把cda存放在偏移量为8的地方满足对齐方式,该成员变量占用 sizeof(char)=1个字节;接下来为第三个成员ida分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为9,不是sizeof (int)=4的倍数,为了满足对齐方式对偏移量的约束问题,VC自动填充3个字节(这三个字节没有放什么东西),这时下一个可以分配的地址对于结构的起始地址的偏移量为12,刚好是sizeof(int)=4的倍数,所以把ida存放在偏移量为12的地方,该成员变量占用sizeof(int)=4个字节;这时整个结构的成员变量已经都分配了空间,总的占用的空间大小为:8+1+3+4=16,刚好为结构的字节边界数(即结构中占用最大空间的类型所占用的字节数sizeof(double)=8)的倍数,没有空缺的字节需要填充。所以整个结构的大小为:sizeof(struct1)=8+1+ 3+4=16,其中有3个字节是VC自动填充的,没有放任何有意义的东西。

下面再举个例子,交换一下上面的struct1的成员变量的位置,使它变成下面的情况:

struct mystruct2
{
  char cda;
  double dda;
  int ida;
};

运行结果为:24

struct mystruct2
{
  char cda;  //偏移量为0,满足对齐方式,cda占用1个字节;
  double dda; //下一个可用的地址的偏移量为1,不是sizeof(double)=8
         //的倍数,需要补足7个字节才能使偏移量变为8(满足对齐
         //方式),因此VC自动填充7个字节,dda存放在偏移量为8
         //的地址上,它占用8个字节。 

  int ida;   //下一个可用的地址的偏移量为16,是sizeof(int)=4的倍
         //数,满足int的对齐方式,所以不需要VC自动填充,type存
         //放在偏移量为16的地址上,它占用4个字节。

  //所有成员变量都分配了空间,空间总的大小为1+7+8+4=20,不是结构
  //的节边界数(即结构中占用最大空间的类型所占用的字节数sizeof
  //(double)=8)的倍数,所以需要填充4个字节,以满足结构的大小为
  //sizeof(double)=8的倍数。
};

所以该结构总的大小为:sizeof(struct2)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的,没有放任何有意义的东西。

二、#pragma pack(n)来设定变量以n字节对齐方式

VC对结构的存储的特殊处理确实提高CPU存储变量的速度,但是有时候也带来了一些麻烦,我们也屏蔽掉变量默认的对齐方式,自己可以设定变量的对齐方式。VC 中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况:

第一、如果n大于等于该变量所占用的字节数,那么偏移量必须满足默认的对齐方式;

第二、如果n小于该变量的类型所占用的字节数,那么偏移量为n的倍数,不用满足默认的对齐方式。

结构的总大小也有个约束条件,分下面两种情况:如果n大于所有成员变量类型所占用的字节数,那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数;否则必须为n的倍数。下面举例说明其用法:

#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
  char m1;
  double m4;
  int m3;
};
#pragma pack(pop)//恢复对齐状态

以上结构的大小为16,下面分析其存储情况,首先为m1分配空间,其偏移量为0,满足我们自己设定的对齐方式(4字节对齐),m1占用1个字节。接着开始为 m4分配空间,这时其偏移量为1,需要补足3个字节,这样使偏移量满足为n=4的倍数(因为sizeof(double)大于n),m4占用8个字节。接着为m3分配空间,这时其偏移量为12,满足为4的倍数,m3占用4个字节。这时已经为所有成员变量分配了空间,共分配了4+8+4=16个字节,满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16),那么我们可以得到结构的大小为24。

再看下面这个例子:

#pragma pack(8)
struct S1{
  char a;
  long b;
};
struct S2 {
  char c;
  struct S1 d;
  long long e;
};
#pragma pack()

成员对齐有一个重要的条件,即每个成员分别对齐.即每个成员按自己的方式对齐.

也就是说上面虽然指定了按8字节对齐,但并不是所有的成员都是以8字节对齐.其对齐的规则是,每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里是8字节)中较小的一个对齐.并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节.

S1中,成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐;成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8;

S2 中,c和S1中的a一样,按1字节对齐,而d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是按4字节对齐.成员e是8个字节,它是默认按8字节对齐,和指定的一样,所以它对到8字节的边界上,这时,已经使用了12个字节了,所以又添加了4个字节的空,从第16个字节开始放置成员e.这时,长度为24,已经可以被8(成员e按8字节对齐)整除.这样,sizeof(S2)为24个字节.

这里有三点很重要:

1.每个成员分别按自己的方式对齐,并能最小化长度。

2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。

3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。

三、minix的stdarg.h文件中对齐方式

在minix的stdarg.h文件中,定义了如下一个宏:

/* Amount of space required in an argument list for an arg of type TYPE.
 * TYPE may alternatively be an expression whose type is used.
 */

#define __va_rounded_size(TYPE) \
 (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))

从注释以及宏的名字可以看出是有关内存对齐方面的作用。根据前面关于C语言内存对齐方面的理论可知

n字节对齐就是说变量存放的起始地址的偏移量有两种情况:

第一、如果n大于等于该变量所占用的字节数,那么偏移量必须满足默认的对齐方式(各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数);

第二、如果n小于该变量的类型所占用的字节数,那么偏移量为n的倍数,不用满足默认的对齐方式。

此时n = 4,对于sizeof(TYPE)一定为自然数,sizeof(int) - 1 = 3

sizeof(TYPE)只可能出现如下两种情况:

(1) 当sizeof(TYPE) >= 4,偏移量 = (sizeof(TYPE)/4)*4

(2) 当sizeof(TYPE) < 4,偏移量 = 4

此时sizeof(TYPE) = 1 or 2 or 3,而(sizeof(TYPE) + 3) / 4  = 1

为了将上述两种情况统一,偏移量 = ((sizeof(TYPE) + 3) / 4) * 4

在有的源代码中,将内存对齐宏__va_rounded_size通过位操作来实现,代码如下:

#define __va_rounded_size(TYPE) \
  ((sizeof(TYPE)+sizeof(int)-1)&~(sizeof(int)-1))

由于 ~(sizeof(int) – 1) ) = ~(4-1)=~(00000011B)=11111100B

(sizeof(TYPE) + sizeof(int) – 1)就是将大于4m但小于等于4(m+1)的数提高到大于等于4(m+1)但小于4(m+2),这样再& ~(sizeof(int) – 1) )后就正好将原长度补齐到4的倍数了。

相信本文所述对大家C程序设计的学习一定的借鉴价值。

(0)

相关推荐

  • 浅谈C语言的字节对齐 #pragma pack(n)2

    #pragma pack(n) 这是给编译器用的参数设置,有关结构体字节对齐方式设置, #pragma pack是指定数据在内存中的对齐方式. #pragma pack (n)             作用:C编译器将按照n个字节对齐. #pragma pack ()               作用:取消自定义字节对齐方式. #pragma  pack (push,1)     作用:是指把原来对齐方式设置压栈,并设新的对齐方式设置为一个字节对齐 #pragma pack(pop)      

  • C语言内存对齐实例详解

    本文详细讲述了C语言程序设计中内存对其的概念与用法.分享给大家供大家参考之用.具体如下: 一.字节对齐基本概念 现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐. 对齐的作用和原因:各个硬件平台对存储空间的处理上有很大的不同.一些平台对某些特定类型的数据只能从某些特定地址开始存取.比如有些架构的C

  • C++中的内存对齐实例详解

    C++中的内存对齐实例详解 内存对齐 在我们的程序中,数据结构还有变量等等都需要占有内存,在很多系统中,它都要求内存分配的时候要对齐,这样做的好处就是可以提高访问内存的速度. 我们还是先来看一段简单的程序: 程序一 #include <iostream> using namespace std; struct X1 { int i;//4个字节 char c1;//1个字节 char c2;//1个字节 }; struct X2 { char c1;//1个字节 int i;//4个字节 ch

  • C语言柔性数组实例详解

    本文实例分析了C语言柔性数组的概念及用法,对于进一步学习C程序设计有一定的借鉴价值.分享给大家供大家参考.具体如下: 一般来说,结构中最后一个元素允许是未知大小的数组,这个数组就是柔性数组.但结构中的柔性数组前面必须至少一个其他成员,柔性数组成员允许结构中包含一个大小可变的数组,sizeof返回的这种结构大小不包括柔性数组的内存.包含柔数组成员的结构用malloc函数进行内存的动态分配,且分配的内存应该大于结构的大小以适应柔性数组的预期大小.柔性数组到底如何使用? 不完整类型 C和C++对于不完

  • Linux 下C语言连接mysql实例详解

    Linux 下C语言连接mysql实例详解 第一步: 安装mysql, 参考:http://www.jb51.net/article/39190.htm 第二步: 安装mysql.h函数库 sudo apt-get install libmysqlclient-dev 执行之后就可以看到/usr/include/MySQL目录了 然后开始我们的链接. 首先看我的数据库 mysql> show databases; +--------------------+ | Database | +----

  • C语言文件复制实例详解

    C语言文件复制实例详解 文件复制,在Linux中,将生成的read.o 重新文件拷贝一份复制到ReadCopy.o中,并且更改ReadCopy.o文件的操作权限.使其能够正常运行. 实例代码: #include <stdio.h> int main(){ FILE *r_file = fopen ("read.o","rb"); FILE *w_file = fopen ("ReadCopy.o","w"); ch

  • C语言数据结构 快速排序实例详解

    C语言数据结构 快速排序实例详解 一.快速排序简介 快速排序采用分治的思想,第一趟先将一串数字分为两部分,第一部分的数值都比第二部分要小,然后按照这种方法,依次对两边的数据进行排序. 二.代码实现 #include <stdio.h> /* 将两个数据交换 */ void swap(int* Ina , int* Inb) { int temp = *Ina; *Ina = *Inb; *Inb = temp; } /* 进行一趟的快速排序,把一个序列分为两个部分 */ int getPart

  • 对pandas的算术运算和数据对齐实例详解

    pandas可以对不同索引的对象进行算术运算,如果存在不同的索引对,结果的索引就是该索引对的并集. 一.算术运算 a.series的加法运算 s1 = Series([1,2,3],index=["a","b","c"]) s2 = Series([4,5,6],index=["a","c","e"]) print(s1+s2) ''' a 5.0 b NaN c 8.0 e NaN '

  • R语言关于卡方检验实例详解

    卡方检验是一种确定两个分类变量之间是否存在显着相关性的统计方法. 这两个变量应该来自相同的人口,他们应该是类似 是/否,男/女,红/绿等. 例如,我们可以建立一个观察人们的冰淇淋购买模式的数据集,并尝试将一个人的性别与他们喜欢的冰淇淋的味道相关联. 如果发现相关性,我们可以通过了解访问的人的性别的数量来计划适当的味道库存. 语法 用于执行卡方检验的函数是chisq.test(). 在R语言中创建卡方检验的基本语法是 chisq.test(data) 以下是所使用的参数的描述 data是以包含观察

  • C++程序的五大内存分区实例详解

    目录 1.栈内存区 1.1.调用函数时通过栈来传递函数的参数值 1.2.线程占用的栈内存是有上限的 2.堆内存区 3.全局/静态内存区 4.文字常量区 5.程序代码区 C++程序在运行时所占用的内存区域,一般可分为栈内存区.堆内存区.全局/静态内存区.文字常量内存区及程序代码区5大分区: 下面使用日常开发中的编程实例,详细介绍一下这5个分区,以便大家能更深刻的理解这5大内存分区. 1.栈内存区 栈内存区是我们用的最多的分区,只要有函数的地方都会使用到这个分区.栈分区是用来存放函数参数及函数局部变

  • C语言、C++内存对齐问题详解

    这也可以? 复制代码 代码如下: #include <iostream> using namespace std;   struct Test_A {      char a;      char b;      int c; };   struct Test_B {      char a;      int c;      char b; };   struct Test_C {      int c;      char a;      char b; };   int main() {

随机推荐