精华内容
下载资源
问答
  • linux字节对齐规则

    2021-05-03 22:20:15
    在计算内存对齐之前,首先梳理几个概念: 数据成员自身对齐值:该数据成员的大小值 结构体或类的自身对齐值:其成员中自身对齐值最大的那个值 指定对齐值:linux 32默认为4,linux 64默认为8。可以通过@pragma ...

    在计算内存对齐之前,首先梳理几个概念:

    • 数据成员自身对齐值:该数据成员的大小值
    • 结构体或类的自身对齐值:其成员中自身对齐值最大的那个值
    • 指定对齐值:linux 32默认为4,linux 64默认为8。可以通过#pragma pack(value)指定对齐值value
    • 数据成员,结构体和类的有效对齐值:自身对齐值和指定对齐值中较小的那个值

    在计算结构体字节大小时,按照如下步骤进行:

    1. 逐个计算各个数据成员的有效对齐值,统计各个数据成员的起始地址
    2. 算出所有成员地址后,再计算结构体的有效对齐值,查看步骤一计算的结构体大小是否满足结构体有效对齐值的整数倍。若不满足,则在结构体最后一个成员后补充空字节满足要求。

    特殊情况说明:

    • 包括数组、结构体都是复合类型,内存的存储是对基本数据类型的存储
    • attribute ((packed))作用:告诉编译器取消结构在编译过程中的优化对齐

    对于嵌套结构体的对齐规则,说明如下:

    • 嵌套结构体存储的起点必须为该结构体内部成员最大元素的整数倍
    • 嵌套结构体的成员对齐仍满足自身规则
    • 嵌套结构体所占用大小为该结构体内部成员最大元素的整数倍,不足补齐
    • 结构体的总偏移量必须是最大成员的整数倍(包括嵌套结构体中的最大成员

    联合体内存对齐:各个成员是以同一个地址开始存放的,每一个时刻只可以存储一个成员。这样就要求它在分配内存单元时候要满足两点:   

    1. 一般而言,共用体类型实际占用存储空间为其最长的成员所占的存储空间;   
    2. 若是该最长的存储空间对其他成员的元类型,(如果是复合数据类型,取其最宽基本数据类型的数据长度为witch,例int a[5]为4;struct str{char a; int b}为4.)不满足整除关系,该最大空间自动延伸到witch的整倍数;

     

    展开全文
  • 结构体大小 struct Node { char cha; int a; char chb; }; int main() { struct Node nd = {'a',100,'b'}; int size1 = sizeof(nd); int size2 = sizeof(struct Node);...由于存储变量地址对齐的问题,计算

    结构体大小

    struct Node
    {
    	char cha;
    	int a;
    	char chb;
    };
    int main()
    {
    	struct Node nd = {'a',100,'b'};
    	int size1 = sizeof(nd);
    	int size2 = sizeof(struct Node);
    	int size3 = sizeof nd;
    	printf("%d %d %d \n",size1,size2,size3);
    	return 0;
    
    }
    

    在这里插入图片描述
    由于存储变量地址对齐的问题,计算结构体大小有如下3条规则:
    1、结构体变量的首地址,必须是结构体变量中的“最大基本数据类型成员所占字节数的整数倍”。
    2、结构体变量中的每个成员相对于结构体首地址的偏移量,都是该成员基本数据类型所占字节数的整数倍。
    3、结构体变量的总大小,为结构体变量中“最大基本数据类型成员所占字节数”的整数倍。
    假设从0地址开始,a:1字节 ,然后偏移到4的时候才能存储100:4字节,
    现在到达8位置,b:1字节,为了满足总大小必须是最大基本数据类型的整数倍,还要偏移3,最终为:12字节。
    在这里插入图片描述
    8字节

    struct node
    {
    	char ch[3];
    	int ia;
    };
    

    24字节

    struct node
    {
    	char cha
    	double da;
    	char chb;
    };
    

    在这里插入图片描述
    结构体的嵌套:

    struct sdate
    {
    	int year;
    	int month;
    	int day;
    };
    
    struct Student
    {
    	char s_id[10];
    	char s_name[8];
    	struct sdate birthday;
    	double grade;
    };
    

    在这里插入图片描述
    为什么要进行字节对齐呢?
    1、内存大小的基本单位是字节,cpu并不是逐字节读写内存,而是以2,4,8的倍数的字节块来读写内存,所以会对基本数据类型的地址做出一些限制,他的地址必须是2,4,8的倍数,因此各种数据类型就要按一定的规则在空间上排列。
    2、某些平台每次读都是从偶地址开始,如果一个int型(32位系统)如果存放在 偶地址开始的地方,那么读一个周期就能读出32bit,如果存放在奇地址开始的地方,就需要2个周期,并要对两次读出的结果的高低字节进行拼凑才能得到32bit数据,读取效率下降。
    3、由于不同平台对齐方式不同,同样的结构在不同平台大小可能不同,如果互发数据可能错乱,引发严重的问题。
    指定对齐值
    预处理指令#pragma pack(n) n取值是1,2,4,8,16
    vs:8 gcc : 4

    #pragma pack(1)
    struct Node
    {
    	char cha;
    	int a;
    	char chb;
    };
    int main()
    {
    	struct Node nd = {'a',100,'b'};
    	int size1 = sizeof(nd);
    	int size2 = sizeof(struct Node);
    	int size3 = sizeof nd;
    	printf("%d %d %d \n",size1,size2,size3);
    	return 0;
    }
    

    在这里插入图片描述
    1、结构体变量的首地址,必须是min(“结构体变量最大基本数据类型成员所占字节数”,指定对齐方式(比较,取小值))整数倍”。
    2、结构体变量中的每个成员相对于结构体首地址的偏移量,都是min(基本数据类型成员,指定对齐方式(比较))大小的整数倍。
    3、结构体变量的总大小,为(min)结构体变量中“最大基本数据类型成员所占字节数”(将嵌套结构体里的基本数据类型也算上,得到最大基本数据类型成员所占字节数)与指定对齐大小比较,取小的)大小的整数倍。

    由于结构体所占空间与内部元素的类型有关,而且与不同类型元素的排列顺序有关。

    展开全文
  • 但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐对齐的作用和原因:各个硬件平台对存储空间的处理...

    为什么要对齐?

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

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

    二.字节对齐对程序的影响:

    先让我们看几个例子吧(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

    结构体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()的作用.

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

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

    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.

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

    1.在VC IDE中,可以这样修改:[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改,默认是8字节。

    2.在编码时,可以这样动态修改:#pragma pack .注意:是pragma而不是progma.

    五.针对字节对齐,我们在编程中如何考虑?

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

    struct A{

    char a;

    char reserved[3];//使用空间换时间

    int b;

    }

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

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

    代码中关于对齐的隐患,很多是隐式的。比如在强制类型转换的时候。例如:

    unsigned int i = 0x12345678;

    unsigned char *p=NULL;

    unsigned short *p1=NULL;

    p=&i;

    *p=0x00;

    p1=(unsigned short *)(p+1);

    *p1=0x0000;

    最后两句代码,从奇数边界去访问unsignedshort型变量,显然不符合对齐的规定。

    在x86上,类似的操作只会影响效率,但是在MIPS或者sparc上,可能就是一个error,因为它们要求必须字节对齐.

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

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

    1. 编译器的big little端设置

    2. 看这种体系本身是否支持非对齐访问

    3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

    ARM下的对齐处理

    from DUI0067D_ADS1_2_CompLib

    3.13 type  qulifiers

    有部分摘自ARM编译器文档对齐部分

    对齐的使用:

    1.__align(num)

    这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时

    就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。

    这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节

    对齐,但是不能让4字节的对象2字节对齐。

    __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。

    2.__packed

    __packed是进行一字节对齐

    1.不能对packed的对象进行对齐

    2.所有对象的读写访问都进行非对齐访问

    3.float及包含float的结构联合及未用__packed的对象将不能字节对齐

    4.__packed对局部整形变量无影响

    5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定

    义为packed。

    __packed int* p;  //__packed int 则没有意义

    6.对齐或非对齐读写访问带来问题

    __packed struct STRUCT_TEST

    {

    char a;

    int b;

    char c;

    }  ;    //定义如下结构此时b的起始地址一定是不对齐的

    //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]

    //将下面变量定义成全局静态不在栈上

    static char* p;

    static struct STRUCT_TEST a;

    void Main()

    {

    __packed int* q;  //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

    p = (char*)&a;

    q = (int*)(p+1);

    *q = 0x87654321;

    /*

    得到赋值的汇编指令很清楚

    ldr      r5,0x20001590 ; = #0x12345678

    [0xe1a00005]   mov      r0,r5

    [0xeb0000b0]   bl       __rt_uwrite4  //在此处调用一个写4byte的操作函数

    [0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问

    [0xe1a02420]   mov      r2,r0,lsr #8

    [0xe5c12001]   strb     r2,[r1,#1]

    [0xe1a02820]   mov      r2,r0,lsr #16

    [0xe5c12002]   strb     r2,[r1,#2]

    [0xe1a02c20]   mov      r2,r0,lsr #24

    [0xe5c12003]   strb     r2,[r1,#3]

    [0xe1a0f00e]   mov      pc,r14

    */

    /*

    如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败

    [0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321

    [0xe5812000]   str      r2,[r1,#0]

    */

    //这样可以很清楚的看到非对齐访问是如何产生错误的

    //以及如何消除非对齐访问带来问题

    //也可以看到非对齐访问和对齐访问的指令差异导致效率问题

    }

    sizeof进行结构体大小的判断

    typedef struct

    {

    int a;

    char b;

    }A_t;

    typedef struct

    {

    int a;

    char b;

    char c;

    }B_t;

    typedef struct

    {

    char a;

    int b;

    char c;

    }C_t;

    void main()

    {

    char*a=0;

    cout

    为什么是这样的结果啊?

    2. 语法:

    sizeof有三种语法形式,如下:

    1) sizeof( object ); // sizeof( 对象 );

    2) sizeof( type_name ); // sizeof( 类型 );

    3) sizeof object; // sizeof 对象;

    5. 指针变量的sizeof

    既然是来存放地址的,那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中,一

    个指针变量的返回值必定是4(以字节为单位),可以预计,在将来的64位系统

    中指针变量的sizeof结果为8。

    char* pc = "abc";

    int* pi;

    string* ps;

    char** ppc = &pc;

    void (*pf)();// 函数指针

    sizeof( pc ); // 结果为4

    sizeof( pi ); // 结果为4

    sizeof( ps ); // 结果为4

    sizeof( ppc ); // 结果为4

    sizeof( pf );// 结果为4

    指针变量的sizeof值与指针所指的对象没有任何关系,正是由于所有的指针变量所占内存

    大小相等,所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消息结

    构(使用指向结构体的指针)。

    6. 数组的sizeof

    数组的sizeof值等于数组所占用的内存字节数,如:

    char a1[] = "abc";

    int a2[3];

    sizeof( a1 ); // 结果为4,字符串末尾还存在一个NULL终止符

    sizeof( a2 ); // 结果为3*4=12(依赖于int)

    一些朋友刚开始时把sizeof当作了求数组元素的个数,现在,你应该知道这是不对的,那

    么应该怎么求数组元素的个数呢?Easy,通常有下面两种写法:

    int c1 = sizeof( a1 ) / sizeof( char ); // 总长度/单个元素的长度

    int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第一个元素的长度

    写到这里,提一问,下面的c3,c4值应该是多少呢?

    void foo3(char a3[3])

    {

    int c3 = sizeof( a3 ); // c3 ==

    }

    void foo4(char a4[])

    {

    int c4 = sizeof( a4 ); // c4 ==

    }

    也许当你试图回答c4的值时已经意识到c3答错了,是的,c3!=3。这里函数参数a3已不再是

    数组类型,而是蜕变成指针,相当于char* a3,为什么?仔细想想就不难明白,我们调用

    函数foo1时,程序会在栈上分配一个大小为3的数组吗?不会!数组是“传址”的,调用者

    只需将实参的地址传递过去,所以a3自然为指针类型(char*),c3的值也就为4。

    7. 结构体的sizeof

    这是初学者问得最多的一个问题,所以这里有必要多费点笔墨。让我们先看一个结构体:

    struct S1

    {

    char c;

    int i;

    };

    问sizeof(s1)等于多少?聪明的你开始思考了,char占1个字节,int占4个字节,那么加起

    来就应该是5。是这样吗?你在你机器上试过了吗?也许你是对的,但很可能你是错的!V

    C6中按默认设置得到的结果为8。

    Why?为什么受伤的总是我?

    请不要沮丧,我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所占

    的内存字节数,好吧,那就让我们来看看S1的内存分配情况:

    S1 s1 = {  a , 0xFFFFFFFF };

    定义上面的变量后,加上断点,运行程序,观察s1所在的内存,你发现了什么?

    以我的VC6.0为例,s1的地址为0x0012FF78,其数据内容如下:

    0012FF78: 61 CC CC CC FF FF FF FF

    发现了什么?怎么中间夹杂了3个字节的CC?看看MSDN上的说明:

    When applied to a structure type or variable, sizeof returns the actual size,

    which may include padding bytes inserted for alignment.

    原来如此,这就是传说中的字节对齐啊!一个重要的话题出现了。

    为什么需要字节对齐?计算机组成原理教导我们这样有助于加快计算机的取数速度,否则

    就得多花指令周期了。为此,编译器默认会对结构体进行处理(实际上其它地方的数据变

    量也是如此),让宽度为2的基本数据类型(short等)都位于能被2整除的地址上,让宽度

    为4的基本数据类型(int等)都位于能被4整除的地址上,以此类推。这样,两个数中间就

    可能需要加入填充字节,所以整个结构体的sizeof值就增长了。

    让我们交换一下S1中char与int的位置:

    struct S2

    {

    int i;

    char c;

    };

    看看sizeof(S2)的结果为多少,怎么还是8?再看看内存,原来成员c后面仍然有3个填充字

    节,这又是为什么啊?别着急,下面总结规律。

    字节对齐的细节和编译器实现相关,但一般而言,满足三个准则:

    1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除;

    2) 结构体每个成员相对于结构体首地址的偏移量(offset)都是成员大小的整数倍,如有

    需要编译器会在成员之间加上填充字节(internal adding);

    3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍,如有需要编译器会在最末一

    个成员之后加上填充字节(trailing padding)。

    对于上面的准则,有几点需要说明:

    1) 前面不是说结构体成员的地址是其大小的整数倍,怎么又说到偏移量了呢?因为有了第

    1点存在,所以我们就可以只考虑成员的偏移量,这样思考起来简单。想想为什么。

    结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得,这个宏也在

    stddef.h中定义,如下:

    #define offsetof(s,m) (size_t)&(((s *)0)->m)

    例如,想要获得S2中c的偏移量,方法为

    size_t pos = offsetof(S2, c);// pos等于4

    2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型,

    这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型,比

    如另外一个结构体,所以在寻找最宽基本类型成员时,应当包括复合类型成员的子成员,

    而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型

    作为整体看待。

    这里叙述起来有点拗口,思考起来也有点挠头,还是让我们看看例子吧(具体数值仍以VC

    6为例,以后不再说明):

    struct S3

    {

    char c1;

    S1 s;

    char c2

    };

    S1的最宽简单成员的类型为int,S3在考虑最宽简单类型成员时是将S1“打散”看的,所以

    S3的最宽简单类型为int,这样,通过S3定义的变量,其存储空间首地址需要被4整除,整

    个sizeof(S3)的值也应该被4整除。

    c1的偏移量为0,s的偏移量呢?这时s是一个整体,它作为结构体变量也满足前面三个准则

    ,所以其大小为8,偏移量为4,c1与s之间便需要3个填充字节,而c2与s之间就不需要了,

    所以c2的偏移量为12,算上c2的大小为13,13是不能被4整除的,这样末尾还得补上3个填

    充字节。最后得到sizeof(S3)的值为16。

    通过上面的叙述,我们可以得到一个公式:

    结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目,即:

    sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trail

    ing padding )

    到这里,朋友们应该对结构体的sizeof有了一个全新的认识,但不要高兴得太早,有一个

    影响sizeof的重要参量还未被提及,那便是编译器的pack指令。它是用来调整结构体对齐

    方式的,不同编译器名称和用法略有不同,VC6中通过#pragma pack实现,也可以直接修改

    /Zp编译开关。#pragma pack的基本用法为:#pragma pack( n ),n为字节对齐数,其取值

    为1、2、4、8、16,默认是8,如果这个值比结构体成员的sizeof值小,那么该成员的偏移

    量应该以此值为准,即是说,结构体成员的偏移量应该取二者的最小值,公式如下:

    offsetof( item ) = min( n, sizeof( item ) )

    再看示例:

    #pragma pack(push) // 将当前pack设置压栈保存

    #pragma pack(2)// 必须在结构体定义之前使用

    struct S1

    {

    char c;

    int i;

    };

    struct S3

    {

    char c1;

    S1 s;

    char c2

    };

    #pragma pack(pop) // 恢复先前的pack设置

    计算sizeof(S1)时,min(2, sizeof(i))的值为2,所以i的偏移量为2,加上sizeof(i)等于

    6,能够被2整除,所以整个S1的大小为6。

    同样,对于sizeof(S3),s的偏移量为2,c2的偏移量为8,加上sizeof(c2)等于9,不能被

    2整除,添加一个填充字节,所以sizeof(S3)等于10。

    现在,朋友们可以轻松的出一口气了,

    还有一点要注意,“空结构体”(不含数据成员)的大小不为0,而是1。试想一个“不占

    空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢?于是,“

    空结构体”变量也得被存储,这样编译器也就只能为其分配一个字节的空间用于占位了。

    如下:

    struct S5 { };

    sizeof( S5 ); // 结果为1

    8. 含位域结构体的sizeof

    前面已经说过,位域成员不能单独被取sizeof值,我们这里要讨论的是含有位域的结构体

    的sizeof,只是考虑到其特殊性而将其专门列了出来。

    C99规定int、unsigned int和bool可以作为位域类型,但编译器几乎都对此作了扩展,允

    许其它类型类型的存在。

    使用位域的主要目的是压缩存储,其大致规则为:

    1) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字段将

    紧邻前一个字段存储,直到不能容纳为止;

    2) 如果相邻位域字段的类型相同,但其位宽之和大于类型的sizeof大小,则后面的字段将

    从新的存储单元开始,其偏移量为其类型大小的整数倍;

    3) 如果相邻的位域字段的类型不同,则各编译器的具体实现有差异,VC6采取不压缩方式

    ,Dev-C++采取压缩方式;

    4) 如果位域字段之间穿插着非位域字段,则不进行压缩;

    5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。

    还是让我们来看看例子。

    示例1:

    struct BF1

    {

    char f1 : 3;

    char f2 : 4;

    char f3 : 5;

    };

    其内存布局为:

    |_f1__|__f2__|_|____f3___|____|

    |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

    0 3   7 8   1316

    位域类型为char,第1个字节仅能容纳下f1和f2,所以f2被压缩到第1个字节中,而f3只能

    从下一个字节开始。因此sizeof(BF1)的结果为2。

    示例2:

    struct BF2

    {

    char f1 : 3;

    short f2 : 4;

    char f3 : 5;

    };

    由于相邻位域类型不同,在VC6中其sizeof为6,在Dev-C++中为2。

    示例3:

    struct BF3

    {

    char f1 : 3;

    char f2;

    char f3 : 5;

    };

    非位域字段穿插在其中,不会产生压缩,在VC6和Dev-C++中得到的大小均为3。

    9. 联合体的sizeof

    结构体在内存组织上是顺序式的,联合体则是重叠式,各成员共享一段内存,所以整个联

    合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型,这里,

    复合类型成员是被作为整体考虑的。

    所以,下面例子中,U的sizeof值等于sizeof(s)。

    union U

    {

    int i;

    char c;

    S1 s;

    };

    展开全文
  • 很多网上的字节对齐规则是这样: 1.结构体变量的首地址为最宽基本类型成员大小的整数倍数。 2.各成员变量存放的起始地址相对于结构体变量的起始地址的偏移量必须为该变量类型所占用的字节数的倍数 3.结构体总大小...

    今天做招银网络的一道选择题
    在这里插入图片描述
    给的正确答案是C,我选的A,之后又实测了下,认为就应该选A

    很多网上的字节对齐规则是这样:

    • 1.结构体变量的首地址为最宽基本类型成员大小的整数倍数。
    • 2.各成员变量存放的起始地址相对于结构体变量的起始地址的偏移量必须为该变量类型所占用的字节数的倍数
    • 3.结构体总大小为结构体中最宽数据类型成员大小的整数倍。

    按照这样计算

    struct MyStruct
    {
        int i;
        char c;
        struct InnerStruct
        {
            int i;
            long l;
            double d;
            char c;
        } innerStruct;
    };
    

    MyStruct结构体的长度是:
    4(int)
    +1(char)
    +3(根据第一条,补齐InnerStruct首地址为double倍数)
    +4(int)
    +4(32bit-long)
    +8(double)
    +1(char)
    +7(根据第三条,为8的倍数,需要填充7个字节)
    = 32Byte

    其中我认为最有问题的就是第三条

    根据我之前的经验,和我之前看的一篇文章,其正确规则应该是这样

    设对齐字节数为n(n = 4或8,区别于32位或者64位操作系统),每个成员内存长度为Li, Max(Li)为最大的成员内存长度,字节对齐规则是:

    • 1.结构体对象的起始地址能够被Max(Li)所整除;
    • 2.结构体中每个成员相对于起始地址的偏移量,即对齐值应是min(n,Li)的倍数.若不满足对齐值的要求,编译器会在成员之间填充若干个字节;(这里总是容易出错)
    • 3.结构体的总长度值应是min(n,Max(Li))的倍数,若不满足总长度值的要求,编译器在为最后一个成员分配空间后,会在其后填充若干个字节.

    注意第三条的min(n,Max(Li)),也就是说,不仅要参考最大元素的长度,还要看编译器默认字节对齐数的长度。这里要说下,字节对齐和数据类型的长度都是由编译器决定!

    如果按照这个规则,最后一个补齐的字节数就不是double长度的整数倍,而是,min(默认字节对齐长度,8),32位机器一般默认4字节对齐,即只需填充3,最终也就是占28个字节。

    我们知道#pragma pack (n)可以指定字节对齐数,所以我在VS2015上实测
    #pragma pack (4)时,答案为28 4
    #pragma pack (8)时,答案为32 4
    即使不加#pragma pack 强制对齐,在VS x86平台上,其答案也是28 4

    在64位Ubuntu下,利用GCC编译32位程序,实测
    #pragma pack (4)时,答案为28 4
    #pragma pack (8)时,答案为28 4

    很奇怪,可能GCC做了某些优化,因为32位程序一般运行在32位平台上,
    cpu一次访问4字节。

    所以无论怎么说,这道题目,以及网上的有些总结确实存在问题,本文或许也有疏漏,如有问题也可以相互讨论。

    另外,关于嵌套结构体,有些复杂,这里总结下:

    • 内部结构体起始地址必须满足第一条,也就起始地址是其最大元素长度的倍数。如果是内部没有嵌套的结构体,其起始地址由编译器优化,必定是其最大元素长度的倍数,不用管第一条。
    • 外部结构体算字节对齐时,最大元素长度是取外部+内部最大元素的长度,比如例题中的double。
    • 内部结构体尾部也会根据规则填充字节的
      更具体的例子可以参考下面的链接
      https://www.cnblogs.com/sunbines/p/9257981.html
    展开全文
  • C语言共用体字节对齐

    2021-02-24 11:12:03
    以下做单片机共用体字节对齐使用说明: 1、字节对齐代码: #pragma pack (N) /*指定按N字节对齐*/ #pragma pack () /*取消指定对齐,恢复缺省对齐*/ 2、应用示例: #pragma pack (1) /*指定按 1 字节对齐*/...
  • #字节对齐

    2021-03-01 06:39:32
    什么是字节对齐(可以跳过)现代计算机中内存空间都是按照字节(byte)划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定变量的时候经常在特定的内存地址访问,这就需要各类型...
  • 内存字节对齐-

    2021-03-09 09:44:21
    二、为什么要字节对齐需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002...
  • C语言字节对齐详解

    2021-05-18 13:44:37
    C语言字节内存对齐程序在运行时会将数据临时存放在内存中,芯片内核需要对这些数据进行计算,不断的读取内存以获得数据,并将计算结果写入内存。计算机体系经过若干年的发展,最终确定了以8bits作为其基本的存储...
  • 二、对齐规则 对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐: 数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。联合 :按其包含的长度最大的数据...
  • struct 字节对齐

    2021-10-11 13:45:43
    struct 字节对齐 一、概念 对齐:对齐与数据在内存中的位置相关。如果一个变量的内存地址正好位于它长度的整数倍,被称作自然对齐。 如在32位cpu下,假设一个int变量的地址是 0x00000004,它就是自然对齐的 为...
  • struct结构体字节对齐

    2021-05-16 02:43:10
    //--------------------------------------------------------本文目录结构|-为什么结构体内存对齐|-结构体内存对齐规则|-具体举例//--------------------------------------------------------一、为什么结构体内存...
  • 字节对齐问题

    2021-03-09 09:44:25
    32位机器上各种数据类型的长度如下:char:1(有符号无符号同)short:2(有符号无符号同)int:4(有符号无符号同)long:4(有符号无符号同)float:4double:8一、概念对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好...
  • 结构体字节对齐

    2021-05-17 23:52:53
    在用sizeof运算符求算某结构体所占空间时,并不是简单地将结构体中所有元素各自占的空间相加,这里涉及到内存字节对齐的问题。从理论上讲,对于任何 变量的访问都可以从任何地址开始访问,但是事实上不是如此,实际...
  • 基本上用户定义的变量是几个字节就是几字节对齐,这个比较好理解。 uint8_t定义变量地址要1字节对齐。 uint16_t定义变量地址要2字节对齐。 uint32_t定义变量地址要4字节对齐。 uint64_t定义变量地址要8字节对齐。 ...
  • 大小(可以用sizeof来确定)对齐要求(可以通过alignof来确定)(因为C11)存储时间(自动,静态,分配,线程本地)寿命(等于存储时间或临时)有效的类型(见下文)价值(可能是不确定的)可选地,表示该对象的标识符对象由声明,...
  • 1.什么是字节对齐在c语言的结构体里面一般会按照某种规则去进行字节对齐。我们先看一段代码:struct st1{char name;double age;char sex;};//32位下 sizeof(struct st1) = 16//64位下 sizeof(struct st1) = 24struct...
  • C++结构体字节对齐

    2021-05-21 19:14:50
    计算机系统对基本类型数据在内存中存放的位置有限制,要求这些数据的起始地址的值是某个数k的倍数,这就是所谓的内存对齐,而这个k则被称为该数据类型的对齐模数(alignment modulus)。结构的存储分配编译器按照...
  • linux下字节对齐

    2021-05-12 05:53:04
    32位系统中,数据总线宽度为32,每次能够读取4字节数据。地址总线为32,最大寻址空间为4GB。但是由于最低位A[0]~A[1]是不用于寻址的,因此只能访问4的倍数的地址空间,但是寻址空间还是2^30*字长=4GB。因此内存中...
  • 测试环境:ubuntu 64位1、对齐原因在设计不同cpu下的通信协议,或者编写硬件驱动程序时,可能需要按字节对齐。即使是看起来就是自然对齐的,也要设置字节对齐,以免不同编译器生成的代码不一样。理论上来说,处理器...
  • C语言字节对齐

    2020-12-22 09:17:19
    声明:本文是为了记录学习过程,一切文献来源于以下博客!!! ...一、概念    对齐跟数据在内存中的位置有关。... 需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比
  • C语言中的字节对齐和对程序的影响字节对齐的概念字节对齐对程序的影响#pragma指令设置 字节对齐编译器对字节对齐的原则字节对齐的编程设置位段定义字节对齐的概念:现代计算机中内存空间都是按照byte来划分的,从理论...
  • C语言的字节对齐

    2021-01-19 09:37:29
    一、基本概念 1. 什么是自然对齐 对于一个存储在内存中的变量,如果它的内存...例子:以32位的CPU为例,32位的CPU,默认是4字节[32 / 8 = 4]对齐。 当整型数据A的存储起始地址为0x2,则它在内存中的数据占据了4..
  • AAPCS 堆栈8字节对齐

    2021-08-11 22:45:30
    AAPCS规则要求堆栈保持8字节对齐。如果不对齐,调用一般的函数也是没问题的。但是当调用需要严格遵守AAPCS规则的函数时可能会出错。 例如调用sprintf输出一个浮点数时,栈必须是8字节对齐的,否则结果可能会出错。 ...
  • C++中的字节对齐

    2021-02-05 11:10:36
    一、字节对齐的定义 计算机在访问特定类型变量的时候经常在特定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。 二、对齐的作用和原因: 1、平台...
  • 今天我们总结在C++和C语言中让我们头疼的字节对齐问题:一、首先来看什么是字节对齐?现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定...
  • 结构体字节对齐在用sizeof运算符求算某结构体所占空间时,并不是简单地将结构体中所有元素各自占的空间相加,这里涉及到内存字节对齐的问题。从理论上讲,对于任何 变量的访问都可以从任何地址开始访问,但是事实上...
  • 结果为28 google了一下 Win32平台下的微软C编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小,即sizeof(T)。比如对于double类型(8字节),就要求该类型数据的...
  • 看一个始终困扰初学者的问题:字节对齐!先看四个重要的基本概念:1.数据类型自身的对齐值:对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,单位字节。2.结构体或者...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,312
精华内容 17,724
关键字:

字节对齐规则

友情链接: Thread.rar