结构体内存对齐，位段，联合体

目录

结构体内存对齐

1.对齐方法（三步对齐）

练习 

​编辑

 2.对齐原因

a.平台原因

b.性能原因

3.修改默认对齐数 

位段

1.位段的声明

2.位段的内存分配规则

练习

3.位段的缺点

联合体 

1.存储特点

例题1

例题2 

例题3

2.成员数据在内存里的存放方式

例题一

---

结构体内存对齐

1.对齐方法（三步对齐）

①第一个成员在结构体地址偏移量为0处

②成员大小与对齐数（vs的默认为8）比较，二者取较小值，然后将该成员放入以该成员大小整数倍的地址

③最后检查结构体的地址大小是否为最大对齐数的整数倍，不是则补齐大小，已达整数倍。

举个栗子：

ps:结构体嵌套的话，可以把内嵌的结构体看成一个成员，来进行计算，由内而外的进行大小计算

练习 

//练习1
    struct S1
    {
        char c1;
        int i;
        char c2;
    };
    printf("%d\n", sizeof(struct S1));
//练习2
    struct S2
    {
        char c1;
        char c2;
        int i;
    };
    printf("%d\n", sizeof(struct S2));
//练习3
    struct S3
    {
        double d;
        char c;
        int i;
    };
    printf("%d\n", sizeof(struct S3));
//练习4-结构体嵌套
    struct S4
    {
        char c1;
        struct S3 s3;
        double d;
    };
    printf("%d\n", sizeof(struct S4));

答案：（1）12，（2） 8， （3）16，（4） 32。

下图为（1）的图解，（2）（3）（4）略

 2.对齐原因

a.平台原因

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。

b.性能原因

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。

总而言之：结构体对齐就是拿空间换时间的一种做法

3.修改默认对齐数 

#pragma pack()//取消设置的默认对齐数，还原为默认

#pragma pack(1)//设置对齐数为1，即为不对齐，直接相加得结构体大小

#pragma pack(8) //设置对齐数为8

 如下代码练习：

#pragma pack(8)//设置默认对齐数为8
    struct S1
    {
        char c1;
        int i;
        char c2;
    };
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
    struct S2
    {
        char c1;
        int i;
        char c2;
    };
#pragma pack()//取消设置的默认对齐数，还原为默认
    printf("对齐数为8下的结构体大小：%d\n", sizeof(struct S1));
    printf("对齐数为1下的结构体大小：%d\n", sizeof(struct S2));

答案：

位段

简单理解：就是对结构体内存更细致的分配管理。

1.位段的声明

位段的声明和结构是类似的，有两个不同：
①位段的成员必须是 int、unsigned int 或signed int 。
②位段的成员名后边有一个冒号和一个数字。

如图所示：

struct A
{
    int _a:2;
    int _b:5;
    int _c:10;
    int _d:30;
};
printf("%d\n", sizeof(struct A));

ps:这里的数字表示变量给分配的比特位

一般来说 ，位段的类型都是统一一种类型来定义，且给每个成员分配1字节（char一个）或4字节（int四个），然后后面数字来控制在这空间内分配多少个可用比特位。

2.位段的内存分配规则

以上题举例：算struct A的大小

类型为int型，所以每个分配4个字节内存；
_a:2    表示a只有2个比特位的大小可用，
_b:5    表示b只有5个比特位的大小可用，
_c:10  表示c只有2个比特位的大小可用，
_d:30  表示d只有5个比特位的大小可用。
4个字节，32个比特位，所以_a,_b,_c的内容都放在第一个int字节里，_d的内容放在第二个int字节里。vs2022下的结构示意图：（vs下是小端存储，一个长方格为一个字节）

很显然，这个位段的大小为8个字节 

我们来看一道题来判断位段是否是上图所分配的那样 

struct S
{
    char a : 3;
    char b : 4;
    char c : 5;
    char d : 4;
};
int main()
{
    struct S s = { 0 };
    s.a = 10;
    s.b = 12;
    s.c = 3;
    s.d = 4;
    return 0;
}

 由此可知，在vs2022的环境下确实是如此分配的

练习

• T1

#define MAX_SIZE A+B
struct _Record_Struct
{
  unsigned char Env_Alarm_ID : 4;
  unsigned char Para1 : 2;
  unsigned char state;
  unsigned char avail : 1;
}*Env_Alarm_Record;
struct _Record_Struct *pointer = (struct _Record_Struct*)malloc
(sizeof(struct _Record_Struct) * MAX_SIZE);

当A=2， B=3时，pointer分配（ ）个字节的空间。 

• T2

int main()
{
  unsigned char puc[4];
  struct tagPIM
  {
    unsigned char ucPim1;
    unsigned char ucData0 : 1;
    unsigned char ucData1 : 2;
    unsigned char ucData2 : 3;
  }*pstPimData;
  pstPimData = (struct tagPIM*)puc;
  memset(puc,0,4);
  pstPimData->ucPim1 = 2; 
  pstPimData->ucData0 = 3;
  pstPimData->ucData1 = 4;
  pstPimData->ucData2 = 5;
  printf("%02x %02x %02x %02x\n",puc[0], puc[1], puc[2], puc[3]);
  return 0;
}

 打印的内容是?

---

答案1：
结构体向最长的char对齐，前两个位段元素一共4+2位，不足8位，合起来占1字节，最后一个单独1字节，一共3字节。另外，#define执行的是查找替换， sizeof(struct _Record_Struct) * MAX_SIZE这个语句其实是3*2+3，结果为9。

答案2：
puc是一个char数组，每次跳转一个字节，结构体不是，它只有第一个元素单独享用一字节，其他三个元素一起共用一字节，所以puc被结构体填充后，本身只有两个字节会被写入，后两个字节肯定是0，然后第一个字节是2就是2了，第二个字节比较麻烦，首先ucData0给了3其实是越界了，1位的数字只能是0或1，所以11截断后只有1，同理ucData1给的4也是越界的，100截断后是00，只有5的101是正常的。填充序列是类似小端的低地址在低位，所以排列顺序是00 101 00 1。也就是0010 1001，即0x29，

3.位段的缺点

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

• 总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在

联合体 

1.存储特点

联合体的内存是共用内存，按照成员变量的最大内存来存放。

对齐规则：
①联合的大小至少是最大成员的大小。
②当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

ps:对齐数只根据基本类型的大小来判断，其他类型的都可以拆分为基本类型中最大的来计算

（详见例题3）

例题1

union Un1
{
	char c[5]; // 对齐数1（char）
	int i;     // 对齐数4（int）
};

 解：这里最大成员大小为4，刚好是对齐数的整数倍，所以内存大小为4。

例题2 

union Un2
{
	short c[7];  // 对齐数2（short）
	int i;       // 对齐数4（int）
};

 解：这里最大成员大小为2*7=14，不是最大对齐数的整数倍，所以内存大小补上2，为16byte。

例题3

union MyUnion
{
	char arr[10]; //char(1) 对齐数1
    //结构体属于自定义类型，所以得拆分看里面最大成员的大小（这里为int-4，所以最大对齐数4）
	struct mystruct
	{
		short arr2[5];  // short(2) 对齐数2
		int c;          // int(4) 对齐数4
	};
};

解：这里的最大成员是结构体，他的大小为2*5(arr2)+2(对齐补上的空白内存)+4(c)=16byte，刚好是最大对齐数（int---4）的整数倍，这里不能把结构体看成一整个大的对齐数，要细分计算才是正确的。所以最后这个联合体的大小为16byte。

2.成员数据在内存里的存放方式

说完了内存存放方式，我们知道联合体的数据都是共用一块内存大小，那么来看看数据是如何在内存中协调存放的，彼此之间又有什么关联。

例题一

来思考一下这题，变量a和b分别为何值？

    union Content
    {
        char a;
        int b;
    };
    union Content n;
    n.a = 0;
    n.b = 1;
    printf("a = %d，b = %d\n", n.a, n.b);

结果是a=1,b=1；我们可以从中得知，联合体的数据是进行覆盖处理的，后赋值的数据会覆盖掉前面赋值的数据，其原因还是因为共用同一块内存。

来看看内存运行情况

 总结：联合体的内存是根据最大成员的大小与最大对齐数来进行分配的，联合体里的成员变量值存在彼此覆盖赋值的情况，需要注意。