• 参考文章：结构体大小与内存对齐问题

• 参考文章：C内存对齐原则

目录

• 结构体介绍
• 结构体大小及内存对齐

结构体介绍

一、结构体的声明及类型定义

声明

struct lcpoint{
    float x;
    float y;
};

类型定义

//定义了一个新的类型LCDate,与int short等地位是相等的，是一个新的类型。
typedef struct{
    int year;
    int month;
    int day;
}LCDate;

二、结构体的使用

//初始化一个结构体变量并初始化
struct lcpoint p = {5.0,6.0};

//访问结构体的成员变量
p.x = 7.0;
p.y = 8.0;
printf("p.x=%f,p.y=%f\n",p.x,p.y);

//另外一种赋值方式
p = (struct lcpoint){9.0,10.0};
printf("p.x=%f,p.y=%f\n",p.x,p.y);

//通过类型 初始化一个结构体变量，并初始化
LCDate date = {2017,5,2};

//访问结构体变量
date.year = 2018;
date.month = 6;
date.day = 1;
printf("date.year=%d,date.month=%d,data.day=%d\n",date.year,date.month,date.day);

//另外一种赋值方式
date = (LCDate){2025,1,1};
printf("date.year=%d,date.month=%d,data.day=%d\n",date.year,date.month,date.day);

三、结构体指针

//初始化一个结构体变量并初始化
struct lcpoint p = {5.0,6.0};

//结构体指针pp
struct lcpoint * pp = &p;
printf("pp=%p\n",pp);
printf("pp->x=%f,pp->y=%f\n",pp->x,pp->y);


LCDate date = {2018,6,1};

//结构体指针datep
LCDate * datep = &date;
printf("datep=%p\n",datep);
printf("datep->year=%d,datep->month=%d,datep->day=%d\n",datep->year,datep->month,datep->day);

//结构体指针datep2
LCDate * datep2 = &(LCDate){2019,6,1};
printf("datep2->year=%d,datep2->month=%d,datep2->day=%d\n",datep2->year,datep2->month,datep2->day);    

//定义一个结构体类型
typedef struct{
    int year;
    int month;
    int day;
}LCDate;

//定义一个结构体指针类型
typedef LCDate* LCDatePoint;


LCDatePoint datePoint = &(LCDate){2019,6,1}; 
printf("datePoint->year=%d,datePoint->month=%d,datePoint->day=%d\n",datePoint->year,datePoint->month,datePoint->day);

结构体大小及内存对齐

结构体中的成员可以是不同的数据类型，成员按照定义时的顺序依次存储在连续的内存空间。
但需要考虑到系统在存储结构体变量时的地址对齐问题。

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

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

一、先介绍几个概念

1. 自对齐值：自身长度的对齐值，char为1，short为2，int为4，float为4，double为8，结构体自对齐值为成员中自对齐值最大的那个值，单位字节。
2. 指定对齐值：顾名思义就是指定的值。#pragma pack (value)，指定对齐值value。
3. 有效对齐值：自对齐值和指定对齐值中较小的那一个。但当用__attribute__ ((packed))指定长度时，强制按照此值为有效对齐值。

有效对齐值N是用来决定数据地址分布的。有效对齐N，就是表示“对齐在N上”。也就是说要满足： 数据地址 % N=0 。
结构体本身也要根据自身的有效对齐值圆整。(就是结构体大小需要是结构体有效对齐值的整数倍)。

按照此规则，假设指定对齐值是4，那么：
char类型的有效对齐值就是1，地址值可以是任意值。
shor类型的有效对齐值就是2，地址值只能是偶数值。
int类型的有效对齐值就是4，地址值只能放在 0x00 0x04 0x08 0x0c 0x10 这样的是4的整数倍的值。
double类型的有效对齐值就是4，地址值只能是4的倍数。

二、分析几个结构体

1.定义结构体如下

struct stru1{
　　int i;      //4字节
　　char c;     //1字节
　　int j;      //4字节
}

假设指定对齐值是4。数据从0x0000地址开始排放。

既然不满足规则，那么就进行排布改变，这个过程就是内存对齐的过程。示意如下：

所以综上，结构体stru1占用的地址空间为 0x0000 ~ 0x000b。结构体的大小为12Byte;

2.定义结构体如下：

struct stru2{
　　int k;
　　short t;
}

假设指定对齐值是4。数据从0x0000地址开始排放。

结构体stru2占用的地址空间为 0x0000 ~ 0x0005。结构体的大小为6Byte,不满足圆整，所以会再分配2个字节的空间，使其满足 (4+4)/4 = 2 圆整。
所以综上，stru2占用的地址空间为 0x0000 ~ 0x0007。结构体的大小为8Byte。

3.再看两种形式
大家在定义结构体类型时需要考虑到字节对齐的情况，不同的顺序会影响到结构体的大小。

如下两种形式： 假设指定对齐值是4。数据从0x0000地址开始排放。

形式一：

　struct stru3{
　　char c1;
　　int i;
　　char c2;
}

调整圆整后，stru3占用的地址空间为 0x0000 ~ 0x000b,结构体大小为12Byte。

形式二：

　struct stru4{
　　char c1;
   char c2;
　  int i;
}

stru4占用的地址空间为 0x0000 ~ 0x0007,结构体大小为8Byte。

三、嵌套类型的结构体
定义结构体如下：

struct stru5{
　　short i;

　　struct{
　　  char c;
　　  int j;
　　} ss;

　　int k;
}

假设指定对齐值是4。数据从0x0000地址开始排放。

这里需要注意的是结构体ss。ss.c的地址究竟能不能是0x0002？因为从规则来看，0x0002能满足ss.c的P%N = 0 。
但要考虑到结构体ss是其中的一个成员，应当作为一个整体，其有效对齐值是4。可知其起始地址应该是 0x0004 而不是 0x0002.
另外结构体ss自身也需要满足规则，如下：

stru4占用的地址空间为 0x0000 ~ 0x0011,结构体大小为16Byte。

行者常至，为者常成！