全球彩票平台_全球彩票注册平台|官网下载地址

热门关键词: 全球彩票平台,全球彩票注册平台,全球彩官网下载地址

全球彩票注册平台C语言字节对齐问题详解,C语言

C语言内存浅谈

操作系统的内存分配问题与内存对齐问题对于地层程序设计来说是非常重要的,对内存分配的理解直接影响到代码质量、正确率、效率以及程序员对内存使用情况、溢出、泄露等的判断力。而内存对齐是常常被忽略的问题,理解内存对齐原理及方法则有助于帮助程序员判断访问非法内存。一般c/c 程序占用的内存主要分为以下五种:
1.栈区(stack):系统自动分配,由程序自动创建、自动释放。函数参数、局部变量以及返回值等信息都存在其中
2.堆区(heap):使用自由,不需要预先确定大小。多少情况下需要程序员手动申请、释放。如果不释放,程序结束后有操作系统垃圾回收机制收回。例如,s = (char *)malloc(10),
3.静态区/全局区(static):全局变量和静态变量的存储区域。程序结束后由系统释放
4.常量区:用于存放常量的内存区域
5.代码区:存放代码
例如:
#include
int quanju;/*全局变量,全局区/静态区(static)*/
void fun(int f_jubu); /*程序代码区*/
int main(void)/**/
{
int m_jubu;/*栈区(stack)*/
static int m_jingtai;/*静态变量,全局区/静态区(static)*/
char *m_zifum,*m_zifuc = "hello";/*指针本身位于栈。指向字符串"hello",位于文字常量区*/
void (*pfun)(int); /*栈区(stack)*/
pfun=&fun;
m_zifum = (char *)malloc(sizeof(char)*10);/*指针内容指向分配空间,位于堆区(heap)*/
pfun(1);
printf("&quanju : %x/n",&quanju);
printf("&m_jubu : %x/n",&m_jubu);
printf("&m_jingtai: %x/n",&m_jingtai);
printf("m_zifuc : %x/n",m_zifuc);
printf("&m_zifuc : %x/n",&m_zifuc);
printf("m_zifum : %x/n",m_zifum);
printf("&m_zifum : %x/n",&m_zifum);
printf("pfun : %x/n",pfun);
printf("&pfun : %x/n",&pfun);
getch();
return 0;
}
void fun(int f_jubu)
{
static int f_jingtai;
printf("&f_jingtai: %x/n",&f_jingtai);
printf("&f_jubu : %x/n",&f_jubu);/*栈区(stack),但是与主函数中m_jubu位于不同的栈*/
}
堆和栈
1.申请方式
stack:
由系统自动分配。例如,在函数中声明一个局部变量char c;系统自动在栈中为c开辟空间
heap:
需要程序员手动申请,并指明大小,在c中,有malloc函数完成。如p1 = (char *)malloc(10)
2.申请后系统的响应
stack:
只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。
heap:
大多数操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的free函数才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中
3.申请大小的限制
stack:
在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小
heap:
堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大
4.申请效率的比较
stack:
由系统自动分配,速度较快。是程序员无法控制的
heap:
由程序员手动分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便
5.堆和栈中的存储内容
stack:
在函数调用时,第一个进栈的是函数调用语句的下一条可执行语句的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。 当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是函数中的下一条指令,程序由该点继续运行
heap:
一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排
内存对齐问题
现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定变量的时候经常在特定的内存地址访问,这就需要各类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。通常,我们写程序的时候,不需要考虑对齐问题。编译器会替我们选择适合目标平台的对齐策略。当然,我们也可以通知给编译器传递预编译指令而改变对指定数据的对齐方法。
1.内存对齐的原因
各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。其他平台可能没有这种情况, 但是最常见的是如果不按照适合其平台的要求对数据存放进行对齐,会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始,如果一个int型(假设为 32位)如果存放在偶地址开始的地方,那么一个读周期就可以读出,而如果存放在奇地址开始的地方,就可能会需要2个读周期,并对两次读出的结果的高低 字节进行拼凑才能得到该int数据。显然在读取效率上下降很多。这也是空间和时间的博弈
2.正确处理字节对齐
对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:
a.数组:按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了
b.联合:按其包含的长度最大的数据类型对齐
c.结构体:结构体中每个数据类型都要对齐
从结构体的首地址开始向后依次为每个成员寻找第一个满足条件的首地址x,该条件是x % N = 0,并且整个结构的长度必须为各个成员所使用的对齐参数中最大的那个值的最小整数倍,不够就补空字节
3.对齐规则
每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n),n=1,2,4,8,16来改变这一系数,其中的n就是你要指定的“对齐系数”。对齐规则如下:
a.数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员的对齐按照#pragma pack指定的数值(或默认值)和这个数据成员类型长度中,比较小的那个进行。在上一个对齐后的地方开始寻找能被当前对齐数值整除的地址
b.结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐.主要体现在,最后一个元素对齐后,后面是否填补空字节,如果填补,填补多少.对齐将按照#pragma pack指定的数值(或默认值)和结构(或联合)最大数据成员类型长度中,比较小的那个进行
c.结合1、2可推断:当#pragma pack的n值等于或超过所有数据成员类型长度的时候,这个n值的大小将不产生任何效果
4.有四个概念值:
1.数据类型自身的对齐值:就是上面交代的基本数据类型的自身对齐值。
2.指定对齐值:#pragma pack (value)时的指定对齐值value。
3.结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
4.数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中较小的那个值。
由于各个平台和编译器的不同,我的使用的gcc version 4.1.2 20080704 (Red Hat 4.1.2-52),来讨论编译器对struct数据结构中各个成员如何进行对齐的。例如:
1.struct A {
int a;
char b;
short c;
}; #结构体A中包含了4字节长度的int一个,1字节长度的char一个和2字节长度的short型数据一个。所以A用到的空间应该是7字节。但是因为编译器要对数据成员在空间上进行对齐,所以使用sizeof(strcut A)值为8。
2.struct B {
char b;
int a;
short c;
};
#假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。第一个成员变量b的自身对齐值是1,比指定或者默认指 定对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a,其自身对齐值为4,所以有效对齐值也为 4,所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐 值为2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存 放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求, 0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12
3.#pragma pack(2) /*指定按2字节对齐*/
struct C {
char b;
int a;
short c;
};
#pragma pack() /*取消指定对齐,恢复缺省对齐*/
#们使用预编译指令#pragma pack (value)来告诉编译器。第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1= 0;第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
在0x0006、0x0007中,符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以 C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8
4.#pragma pack (1) /*指定按1字节对齐*/
struct D {
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
#sizeof(struct C)值是7
5.union E{
int a[5];
char b;
double c;
}; #我想的是union中变量共用内存,应以最长的为准,那就是20。可实际不然E中各变量的默认内存对齐方式,必须以最长的double 8字节对齐,故应该是sizeof(E)=24
注意:
1.数组对齐值为:min(数组元素类型,指定对齐长度).但数组中的元素是连续存放,存放时还是按照数组实际的长度.
如char t[9],对齐长度为1,实际占用连续的9byte.然后根据下一个元素的对齐长度决定在下一个元素之前填补多少byte.
2.嵌套的结构体假设
struct A
{
......
struct B b;
......
};
对于B结构体在A中的对齐长度为:min(B结构体的对齐长度,指定的对齐长度).B结构体的对齐长度为:上述2中结构整体对齐规则中的对齐长度.

操作系统的内存分配问题与内存对齐问题对于地层程序设计来说是非常重要的,对内存分配的理解直接影响到代码质量、正...

内存对齐

文章最后本人做了一幅图,一看就明白了,这个问题网上讲的不少,但是都没有把问题说透。

C语言字节对齐问题详解

一、何谓字节对齐?
现代计算机中内存空间都是按照字节(byte)划分的,从理论上讲,似乎对任何类型变量的访问都可以从任何地址开始,但实际情况是在访问特定变量的时候,经常在特定的内存地址访问,而不是顺序的一个接一个的排放。为了使CPU能够对变量进行快速访问,变量的起始地址应该具有某些特性,即所谓的“字节对齐”。比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除。
在C语言中,结构体是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构体、联合等)的数据单元。在结构体中,编译器为结构体的每个成员按其自然边界(alignment)分配空间,各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。

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

三、字节对齐原则
编译器是按照什么样的原则进行对齐的?在我们继续分析具体字节对齐问题之前,先让我们看几个重要的基本概念:
1.数据类型自身的对齐值:在32位x86机器上,对于char型数据,其自身对齐值为1字节;对于short型,其自身对齐为2字节;对于 int,long, float类型,其自身对齐值为4字节;
对于long long,double类型为8字节;对于基本类型的指针类型(其本质是 unsigned long型),其自身对齐为4字节。
2.结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
3.指定对齐值:#pragma pack (value)时的指定对齐值value。
4.编译器默认对齐值:一般与CPU字长位数相同,在32位机器上为4字节,64位机器上为8字节。未指定对齐值时,编译器使用默认对齐值。
5.数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中小的那个值。

有了这些值,我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值,最重要。有效对齐N,就 是表示“对齐在N上”,也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是 数据结构的起始地址。结构体的成员变量要对齐排放,结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整 数倍。

四、字节对齐举例分析
根据字节对齐原则,结合下面例子理解,就明白了。
例子分析:
分析例子B;
struct B {
char b;
int a;
short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。第一个成员变量b的自身对齐值是1,比指定或者默认指 定对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a,其自身对齐值为4,所以有效对齐值也为 4,所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐 值为2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存 放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求, 0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;

同理,分析上面例子C:
#pragma pack (2) /*指定按2字节对齐*/
struct C {
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1= 0;第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
在0x0006、0x0007中,符合0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以 C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

五、总结
有 了以上的解释,相信你对C语言的字节对齐概念应该有了清楚的认识了吧。在网络程序中,掌握这个概念可是很重要的喔,在不同平台之间(比如在Windows 和Linux之间)传递2进制流(比如结构体),那么在这两个平台间必须要定义相同的对齐方式,还要注意字节大端和小端的问题,否则会莫名其妙地出现一些诡异的错误,可是很难排查的哦^_^。

 

六、附源代码

 

[cpp] view plaincopyprint?

  1. /****************************************************************************** Copyright by Javacode007, All rights reserved!
  2. Filename : structsize.c Author : Javacode007
  3. Date : 2012-8-5 Version : 1.0
  4. Description : 结构体类型大小测试 ******************************************************************************/
  5. #include
  6. struct A {
  7. char c; short s;
  8. int i; };
  9.  
  10. #pragma pack(1) /*指定按1字节对齐*/ struct PA
  11. { char c;
  12. short s; int i;
  13. }; #pragma pack() /*取消指定对齐,恢复缺省对齐*/
  14.  
  15. struct B {
  16. char c; int i;
  17. short s; };
  18. #pragma pack(2) /*指定按2字节对齐*/
  19. struct PB {
  20. char c; int i;
  21. short s; };
  22. #pragma pack() /*取消指定对齐,恢复缺省对齐*/
  23.  
  24. int main() {
  25. struct A stA; struct PA stPA;
  26. struct B stB; struct PB stPB;
  27.  
  28. printf("sizeof(A) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stA), &stA.c, &stA.s, &stA.i); printf("sizeof(PA) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stPA), &stPA.c, &stPA.s, &stPA.i);
  29. printf("sizeof(B) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stB), &stB.c, &stB.s, &stB.i); printf("sizeof(PB) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stPB), &stPB.c, &stPB.s, &stPB.i);
  30.  
  31. return 0;
  32. }

    /******************************************************************************
    Copyright by Javacode007, All rights reserved!
    Filename    : structsize.c
    Author      : Javacode007
    Date        : 2012-8-5
    Version     : 1.0
    Description : 结构体类型大小测试
    ******************************************************************************/
    #include 
    
    struct A
    {
        char c;
        short s;
        int i;
    };
    
    #pragma pack(1) /*指定按1字节对齐*/
    struct PA
    {
        char c;
        short s;
        int i;
    };
    #pragma pack()  /*取消指定对齐,恢复缺省对齐*/


    struct B
    {
        char c;
        int i;
        short s;    
    };

    #pragma pack(2) /*指定按2字节对齐*/
    struct PB
    {
        char c;
        int i;
        short s;    
    };
    #pragma pack()  /*取消指定对齐,恢复缺省对齐*/



    int main()
    {
        struct A stA;
        struct PA stPA;
        struct B stB;
        struct PB stPB;


        printf("sizeof(A)  = %d, &c = %p, &s = %p, &i = %prn", sizeof(stA), &stA.c, &stA.s, &stA.i);
        printf("sizeof(PA) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stPA), &stPA.c, &stPA.s, &stPA.i);
        printf("sizeof(B)  = %d, &c = %p, &s = %p, &i = %prn", sizeof(stB), &stB.c, &stB.s, &stB.i);
        printf("sizeof(PB) = %d, &c = %p, &s = %p, &i = %prn", sizeof(stPB), &stPB.c, &stPB.s, &stPB.i);


        return 0;

    }

 


输出结果:

![](http://www.bkjia.com/uploads/allimg/150416/0429523003-0.png)

一、何谓字节对齐? 现代计算机中内存空间都是按照字节(byte)划分的,从理论上讲,似乎对任何类型变量的访问...

 

1.  概念

  一、概念 
   
   对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍,他就被称做自然对齐。比如在32位cpu下,假设一个整型变量的地址为0x00000004,那它就是自然对齐的。
   
  二、为什么要字节对齐
   
   需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002-0x00000003的一个short,第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据,如果变量在0x00000003地址上的话则要访问三次内存,第一次为char,第二次为short,第三次为char,然后组合得到整型数据。而如果变量在自然对齐位置上,则只要一次就可以取出数据。一些系统对对齐要求非常严格,比如sparc系统,如果取未对齐的数据会发生错误,举个例:
   
  char ch[8];
  char *p = &ch[1];
  int i = *(int *)p;
   
  
  运行时会报segment error,而在x86上就不会出现错误,只是效率下降。
  
  三、正确处理字节对齐
  
   对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:
  
  数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。 
  联合 :按其包含的长度最大的数据类型对齐。 
  结构体: 结构体中每个数据类型都要对齐。
  比如有如下一个结构体:
  
  struct stu{
   char sex;
   int length;
   char name[10];
  };
  struct stu my_stu;
   
  
  由于在x86下,GCC默认按4字节对齐,它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。于是我们sizeof(my_stu)会得到长度为20,而不是15.
  
  四、__attribute__选项
  
  我们可以按照自己设定的对齐大小来编译程序,GNU使用__attribute__选项来设置,比如我们想让刚才的结构按一字节对齐,我们可以这样定义结构体
  
  struct stu{
   char sex;
   int length;
   char name[10];
  }__attribute__ ((aligned (1))); 
  
  struct stu my_stu;
   
  
  则sizeof(my_stu)可以得到大小为15。
  
  上面的定义等同于
  
  struct stu{
   char sex;
   int length;
   char name[10];
  }__attribute__ ((packed)); 
  struct stu my_stu;
   
  
  __attribute__((packed))得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐.
  
  五、什么时候需要设置对齐
  
   在设计不同CPU下的通信协议时,或者编写硬件驱动程序时寄存器的结构这两个地方都需要按一字节对齐。即使看起来本来就自然对齐的也要使其对齐,以免不同的编译器生成的代码不一样.

当你看到这个标题,仍想往下读的时候说明你已经开始关注数据在内存存储问题了。

  对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍,他就被称做自然对齐。比如在32位cpu下,假设一个整型变量的地址为0x00000004,那它就是自然对齐的。

 

好吧,下面先想一个问题:

1.1为什么要字节对齐

一、快速理解

struct  stu{
char sex;
int length;
char name[10];
};
sizeof (struct  stu) = ???

 需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002-0x00000003的一个short,第二次取从0x00000004-0x00000005的一个 short然后组合得到所要的数据,如果变量在0x00000003地址上的话则要访问三次内存,第一次为char,第二次为short,第三次为 char,然后组合得到整型数据。而如果变量在自然对齐位置上,则只要一次就可以取出数据。一些系统对对齐要求非常严格,比如sparc系统,如果取未对齐的数据会发生错误,举个例:

  1. 什么是字节对齐?

如果你的答案是:15 。那你该仔细看看下面的分析了!!!!

  char ch[8];

在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。在结构中,编译器为结构的每个成员按其自然边界(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。

一、概念 
 
对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍,他就被称做自然对齐。比如在32位cpu下,假设一个整型变量的地址为0x00000004,那它就是自然对齐的。
 
  二、为什么要字节对齐
 
需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002-0x00000003的一个short,第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据,如果变量在0x00000003地址上的话则要访问三次内存,第一次为char,第二次为short,第三次为char,然后组合得到整型数据。而如果变量在自然对齐位置上,则只要一次就可以取出数据。一些系统对对齐要求非常严格,比如sparc系统,如果取未对齐的数据会发生错误,举个例:
 
char ch[8];
char *p = &ch[1];
int i = *(int *)p;  

  char *p = &ch[1];

为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”. 比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.

  运行时会报segment error,而在x86上就不会出现错误,只是效率下降。

  int i = *(int *)p;

  1. 字节对齐有什么作用?

  三、正确处理字节对齐

 运行时会报segment error,而在x86上就不会出现错误,只是效率下降。

字节对齐的作用不仅是便于cpu快速访问,同时合理的利用字节对齐可以有效地节省存储空间。

对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:

1.2正确处理字节对齐

对于32位机来说,4字节对齐能够使cpu访问速度提高,比如说一个long类型的变量,如果跨越了4字节边界存储,那么cpu要读取两次,这样效率就低了。但是在32位机中使用1字节或者2字节对齐,反而会使变量访问速度降低。所以这要考虑处理器类型,另外还得考虑编译器的类型。在vc中默认是4字节对齐的,GNU gcc 也是默认4字节对齐。

  数组:按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。 
  联合:按其包含的长度最大的数据类型对齐。 
  结构体:结构体中每个数据类型都要对齐。
  比如有如下一个结构体:

  对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:

  1. 更改C编译器的缺省字节对齐方式

struct stu{
char sex;
int length;
char name[10];
};
struct stu my_stu;  

  数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。

在缺省情况下,C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地,可以通过下面的方法来改变缺省的对界条件:
· 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。
· 使用伪指令#pragma pack (),取消自定义字节对齐方式。

  由于在x86下,GCC默认按4字节对齐,它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。于是我们sizeof(my_stu)会得到长度为20,而不是15.

  联合 :按其包含的长度最大的数据类型对齐。

另外,还有如下的一种方式:
· __attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。
· __attribute__ ((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。

  四、__attribute__选项

 结构体: 结构体中每个数据类型都要对齐。

  1. 举例说明

  我们可以按照自己设定的对齐大小来编译程序,GNU使用__attribute__选项来设置,比如我们想让刚才的结构按一字节对齐,我们可以这样定义结构体

  比如有如下一个结构体:

例1

struct stu{
char sex;
int length;
char name[10];
}__attribute__ ((aligned (1))); 

  struct stu{

struct test
{
char x1;
short x2;
float x3;
char x4;
};

struct stu my_stu;  

   char sex;

由于编译器默认情况下会对这个struct作自然边界(有人说“自然对界”我觉得边界更顺口)对齐,结构的第一个成员x1,其偏移地址为0,占据了第1个字节。第二个成员x2为short类型,其起始地址必须2字节对界,因此,编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4恰好落在其自然边界地址上,在它们前面不需要额外的填充字节。在test结构中,成员x3要求4字节对界,是该结构所有成员中要求的最大边界单元,因而test结构的自然对界条件为4字节,编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

  则sizeof(my_stu)可以得到大小为15。

   int length;

例2

  上面的定义等同于

   char name[10];

#pragma pack(1) //让编译器对这个结构作1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐,恢复为默认4字节对齐

struct stu{
char sex;
int length;
char name[10];
}__attribute__ ((packed)); 
struct stu my_stu;  

  };

这时候sizeof(struct test)的值为8。

__attribute__((packed))得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐.

  struct stu my_stu;

例3

  五、什么时候需要设置对齐

  由于在x86下,GCC默认按4字节对齐,它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。于是我们sizeof(my_stu)会得到长度为20,而不是15.

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;

在设计不同CPU下的通信协议时,或者编写硬件驱动程序时寄存器的结构这两个地方都需要按一字节对齐。即使看起来本来就自然对齐的也要使其对齐,以免不同的编译器生成的代码不一样.

1.3__attribute__选项

这时候sizeof(struct test)的值仍为8。

 

  我们可以按照自己设定的对齐大小来编译程序,GNU使用__attribute__选项来设置,比如我们想让刚才的结构按一字节对齐,我们可以这样定义结构体

二、深入理解

一、快速理解

  struct stu{

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

1. 什么是字节对齐?

   char sex;

        先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义:
struct A
{
        int a;
        char b;
        short c;
};
struct B
{
        char b;
        int a;
        short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)   
short:2(有符号无符号同)   
int:4(有符号无符号同)   
long:4(有符号无符号同)   
float:4        double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。在结构中,编译器为结构的每个成员按其自然边界(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。

   int length;

结构体A中包含了4字节长度的int一个,1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1:
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”.比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.

   char name[10];

三.编译器是按照什么样的原则进行对齐的?

2. 字节对齐有什么作用?

  }__attribute__ ((aligned (1)));

        先让我们看四个重要的基本概念:

字节对齐的作用不仅是便于cpu快速访问,同时合理的利用字节对齐可以有效地节省存储空间。

  struct stu my_stu;

1.数据类型自身的对齐值:
      对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,单位字节。
2.结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
3.指定对齐值:#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中小的那个值。
有了这些值,我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值,最重要。有效对齐N,就是表示“对齐在N上”,也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放,结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍,结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析:
分析例子B;
struct B
{
        char b;
        int a;
        short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。第一个成员变量b的自身对齐值是1,比指定或者默认指定对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a,其自身对齐值为4,所以有效对齐值也为4,所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求,0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了,因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1=0;第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
在0x0006、0x0007中,符合0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

对于32位机来说,4字节对齐能够使cpu访问速度提高,比如说一个long类型的变量,如果跨越了4字节边界存储,那么cpu要读取两次,这样效率就低了。但是在32位机中使用1字节或者2字节对齐,反而会使变量访问速度降低。所以这要考虑处理器类型,另外还得考虑编译器的类型。在vc中默认是4字节对齐的,GNU gcc 也是默认4字节对齐。

  则sizeof(my_stu)可以得到大小为15。

四.如何修改编译器的默认对齐值?

3. 更改C编译器的缺省字节对齐方式

  上面的定义等同于

1.在VC IDE中,可以这样修改:[Project]|[Settings],c/c 选项卡Category的Code Generation选项的Struct Member Alignment中修改,默认是8字节。
2.在编码时,可以这样动态修改:#pragma pack .注意:是pragma而不是progma.

在缺省情况下,C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地,可以通过下面的方法来改变缺省的对界条件:
· 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。
· 使用伪指令#pragma pack (),取消自定义字节对齐方式。

  struct stu{

五.针对字节对齐,我们在编程中如何考虑?
        如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做法是显式的插入reserved成员:
             struct A{
               char a;
               char reserved[3];//使用空间换时间
               int b;
}

另外,还有如下的一种方式:
· __attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。
· __attribute__ ((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。

   char sex;

reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.

4. 举例说明

   int length;

六.字节对齐可能带来的隐患:

例1

   char name[10];

        代码中关于对齐的隐患,很多是隐式的。比如在强制类型转换的时候。例如:
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

struct test
{
char x1;
short x2;
float x3;
char x4;
};

  }__attribute__ ((packed));

p=&i;
*p=0x00;
p1=(unsigned short *)(p 1);
*p1=0x0000;
最后两句代码,从奇数边界去访问unsignedshort型变量,显然不符合对齐的规定。
在x86上,类似的操作只会影响效率,但是在MIPS或者sparc上,可能就是一个error,因为它们要求必须字节对齐.

由于编译器默认情况下会对这个struct作自然边界(有人说“自然对界”我觉得边界更顺口)对齐,结构的第一个成员x1,其偏移地址为0,占据了第1个字节。第二个成员x2为short类型,其起始地址必须2字节对界,因此,编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4恰好落在其自然边界地址上,在它们前面不需要额外的填充字节。在test结构中,成员x3要求4字节对界,是该结构所有成员中要求的最大边界单元,因而test结构的自然对界条件为4字节,编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

  struct stu my_stu;

七.如何查找与字节对齐方面的问题:

例2

  __attribute__((packed))得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐.

如果出现对齐或者赋值问题首先查看

#pragma pack(1) //让编译器对这个结构作1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐,恢复为默认4字节对齐

1.4什么时候需要设置对齐

  1. 编译器的big little端设置
  2. 看这种体系本身是否支持非对齐访问
    3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作

这时候sizeof(struct test)的值为8。

  在设计不同CPU下的通信协议时,或者编写硬件驱动程序时寄存器的结构这两个地方都需要按一字节对齐。即使看起来本来就自然对齐的也要使其对齐,以免不同的编译器生成的代码不一样.

举例:

例3

  1. 快速理解

[cpp] view plaincopy

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;

2.1. 什么是字节对齐

  1. #include <stdio.h>  
  2. main()  
  3. {  
  4. struct A {  
  5.     int a;  
  6.     char b;  
  7.     short c;  
  8. };  
  9.   
  10. struct B {  
  11.     char b;  
  12.     int a;  
  13.     short c;  
  14. };  
  15.   
  16. #pragma pack (2) /*指定按2字节对齐*/  
  17. struct C {  
  18.     char b;  
  19.     int a;  
  20.     short c;  
  21. };  
  22. #pragma pack () /*取消指定对齐,恢复缺省对齐*/  
  23.   
  24.   
  25.   
  26. #pragma pack (1) /*指定按1字节对齐*/  
  27. struct D {  
  28.     char b;  
  29.     int a;  
  30.     short c;  
  31. };  
  32. #pragma pack ()/*取消指定对齐,恢复缺省对齐*/  
  33.   
  34. int s1=sizeof(struct A);  
  35. int s2=sizeof(struct B);  
  36. int s3=sizeof(struct C);  
  37. int s4=sizeof(struct D);  
  38. printf("%dn",s1);  
  39. printf("%dn",s2);  
  40. printf("%dn",s3);  
  41. printf("%dn",s4);  
  42. }  

这时候sizeof(struct test)的值仍为8。

在 C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。在结构中,编译器为结构的每个成员按其自然边界(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。

输出:

二、深入理解

为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”. 比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.

8

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

2.2. 字节对齐有什么作用

12

        先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义:
struct A
{
        int a;
        char b;
        short c;
};
struct B
{
        char b;
        int a;
        short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)   
short:2(有符号无符号同)   
int:4(有符号无符号同)   
long:4(有符号无符号同)   
float:4        double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

字节对齐的作用不仅是便于cpu快速访问,同时合理的利用字节对齐可以有效地节省存储空间。

8

结构体A中包含了4字节长度的int一个,1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1:
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

对于32位机来说,4字节对齐能够使cpu访问速度提高,比如说一个long类型的变量,如果跨越了4字节边界存储,那么cpu要读取两次,这样效率就低了。但是在32位机中使用1字节或者2字节对齐,反而会使变量访问速度降低。所以这要考虑处理器类型,另外还得考虑编译器的类型。在vc中默认是4字节对齐的,GNU gcc 也是默认4字节对齐。

7

三.编译器是按照什么样的原则进行对齐的?

2.3. 更改C编译器的缺省字节对齐方式

 

本文由全球彩票平台发布于全球彩票注册平台编程,转载请注明出处:全球彩票注册平台C语言字节对齐问题详解,C语言

TAG标签: 全球彩票平台
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。