c-9 结构体对齐计算等

超、凢脫俗 2023-03-01 13:41 13阅读 0赞

### 结构体成员属性偏移对齐 ###

我们看如下列子，并考虑结构体每个成员属性偏移

struct MyStruct
    {
        
    	char name[9];//9
    	int age;     //4
    	char gender;//1
    	float height;//4
    	double weight;//8
    	// 9+4+1+4+8=26
    };

然后我们查看内存结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]  
我们惊讶的差异在`name`之后空出了3个字节内存`cc`,而在`gender`到`height`内存结构中同样也多出了3个字节的`cc`.一个多出了6个空白字节，那么加上固有的26字节那么这个结构体共占用`32`字节。

造成这样的现象是由于c存在结构体对齐机制引起的，在编译参数由`Zp1,Zp2,Zp4,Zp8,Zp16`控制。比如`Zp1`为对齐大小为1，`Zp8`为8字节对齐。默认为`Zp8`。

上述的例子如果想输出26只需要修改编译参数为`Zp1`即可。

**结构体对齐作用（1）：**  
控制的是每个成员属性对于`结构体初始地址的偏移`。

假设结构体对齐大小为N，结构体成员为Y，结构体初始偏移为X，那么偏移必须为`X%min(N,sizeof(Y))==0`。（其中min函数表示取两个数最小值）

以本例为例：  
构造一个 `MyStruct`对象名为`person`,我们强制假设`person`的地址是0.那么我来计算这个结构体中的每个成员的偏移量。

struct MyStruct
    {
        
    	char name[9];
    	int age;    
    	char gender;
    	float height;
    	double weight;
    };
    void main(int argc,char *argv[],char *envp[]) {
        
    
    	 MyStruct xiao;
    
    
    	getchar();
    
    }

> 我们用假设对齐大小为8。

我们看第一个结构体成员`char name[9];`。由于在结构体第一位所以偏移地址为`0`，由于`0%min(8,9)==0`所以`name`偏移为0。

我们看第二个结构体成员`age`。由于第一个结构体成员`name`大小为`9`,所以`age`偏移量为`9`,我们取模运算 `9%min(8,4)==1`,不符合对齐大小，所增大`12`可以满足 `12%min(8,4)==0`,故偏移为`12`.

后面成员类比不做讲解。

当然我们可以使用系统的API来帮助我们迅速计算成员偏移.

struct MyStruct
    {
    	char name[5];
    	int age;    
    	char gender;
    	double weight;
    	float height;//24
    	
    };
    void main(int argc,char *argv[],char *envp[]) {
    
    	 MyStruct xiao;
    
    	 printf("%d\r\n",offsetof(MyStruct, height));//输出24
    	
    	getchar();
    
    }

offsetof实现是一个宏函数，思想比较简单，构造一个执行0地址的MyStruct，对成员取地址即可

#ifdef __cplusplus
            #define offsetof(s,m) ((size_t)&reinterpret_cast<char const volatile&>((((s*)0)->m)))
        #else
            #define offsetof(s,m) ((size_t)&(((s*)0)->m))

### 结构体整体大小对齐 ###

struct NewMyStruct
    {
        
    	char name[5];//5
    	int age;     //8
    	char gender;//12
    	double weight;//16
    	float height;//24
    	
    };
    void main(int argc,char *argv[],char *envp[]) {
        
    
    	 NewMyStruct xiao;
    
    	 printf("%d\r\n", sizeof(NewMyStruct));
    
    	getchar();
    
    }

根据上一个章节讲解的每个成员的偏移计算，`height`偏移为`24`那么这个结构体大小应该是`24+4=28`(由于`float`大小为`4`，所最后一个成员的偏移加上大小理所当然为结构体大小)

然而结果输出：`32`

**结构体对齐作用（2）：**  
结构体对齐控制整个结构体的大小。

结构体的大小公式：  
设结构体每个成员为 m1,m2,m3…  
对齐大小为`N`  
结构体大小为`Y`

1.  `Temp=min(N,max(sizof(m1),sizeof(m2),sizeof(m3),....))`
2.  `Y%Temp==0`

带入本例

struct NewMyStruct
    {
        
    	char name[5]; //sizeof== 5
    	int age;     //sizeof== 4
    	char gender;//sizeof== 1
    	double weight;//sizeof== 8
    	float height;//sizeof== 4
    	
    };

`Temp = min(8,max(5,4,1,8,4)) = 8`

此时我们知道这个结构体至少大小为28，而 `28%8==4` ，不满足 `Y%Temp==0`，所以size扩大为32。

### 结构体对齐大小控制 ###

除了使用`Zp1,Zp2,Zp4,Zp8,Zp16`控制全局程序结构体大小。还可以使用编译宏指令单独对某个某个结构体，或对后续全部的结构体对齐指定。

1）#pragma pack( [ n] )
    2）#pragma pack( [ [ { push | pop}, ] [  identifier, ] ] [ n ] )

#### \#pragma pack( \[ n\] ) 用法 ####

这个编译宏后面所有的全部对齐为指定数量

//后续所有结构对其为1
    //对齐为1
    #pragma pack(1)
    struct MyStruct
    {
        
    	char name[5];
    };
    //对齐为1
    struct MyStruct2
    {
        
    	char name[5];
    };
    
    #pragma pack(4)
    //对齐为4
    struct MyStruct3
    {
        
    	char name[5];
    };

如果你想控制范围请用如下语法：

//保存当前结构体宏对齐大小
    #pragma pack(push)
    #pragma pack(1)
    //对齐为1
    struct MyStruct
    {
        
    	char name[5];
    };
    //弹出保存的结构体的宏对齐大小
    #pragma pack(pop)
    
    //对齐为默认
    struct MyStruct2
    {
        
    	char name[5];
    };

### 2）\#pragma pack( \[ \[ \{ push | pop\}, \] \[ identifier, \] \] \[ n \] ) ###

第一个参数 push pop 用于 保存或者弹出宏大小。  
第二个参数 设置一个名词  
第三个参数 对齐大小

//保存当前对其大小，并设置对齐大小为1
    #pragma pack(push,myAligment,1)
    //对齐为1
    struct MyStruct
    {
        
    	char name[5];
    };
    //还原保存的对其大小
    #pragma pack(pop,myAligment)
    
    //对齐为默认
    struct MyStruct2
    {
        
    	char name[5];
    	int name2[1];
    
    };

这个编译指令主要用于嵌套用途。

//保存当前对其大小，并设置对齐大小为1
    #pragma pack(push,myAligment,1)
    //对齐为1
    struct MyStruct
    {
        
    	char name[5];
    };
    //保存当前对其大小，并设置对齐大小为4
    #pragma pack(push,myAligment2,4)
    //对齐为4
    struct MyStruct2
    {
        
    	char name[5];
    };
    //还原保存的对其大小由于myAligment2嵌套在myAligment，
    //所以会直接抛弃myAligment2和myAligment
    #pragma pack(pop,myAligment)
    
    
    //对齐为默认
    struct MyStruct3
    {
        
    	char name[5];
    	int name2[1];
    
    };

//保存当前对其大小，并设置对齐大小为1
    #pragma pack(push,myAligment,1)
    //对齐为1
    struct MyStruct
    {
        
    	char name[5];
    };
    //保存当前对其大小，并设置对齐大小为4
    #pragma pack(push,myAligment2,4)
    //对齐为4
    struct MyStruct2
    {
        
    	char name[5];
    };
    //只抛弃对齐4，但是myAligment还在
    #pragma pack(pop,myAligment2)
    
    
    //对齐为1
    struct MyStruct3
    {
        
    	char name[5];
    	int name2[1];
    
    };

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20230208/b11717ec44eb41bfbcfbdf47cad3e841.png