结构体字节对齐

---

1、各变量所占内存大小

32位系统下：
sizeof(short) = 2    sizeof(int) = 4   sizeof(long) = 4  sizeof(double) = 8
sizeof(float) = 4    sizeof(指针) = 4
64位系统下：
sizeof(short) = 2    sizeof(int) = 4   sizeof(long) = 4  sizeof(double) = 8
sizeof(float) = 4    sizeof(指针) = 8

2、结构体字节对齐规则

2.1、结构体中没有相互嵌套

规则如下：
1、每一个变量的起始地址是自身大小的整数倍
2、最终结构体所占字节大小需要是结构体中最大变量的整数倍

#include <iostream>
#include <vector>
using namespace std;
typedef struct mystruct1
{
	int a;   //0-3
	char b;  //4
	short c; //6-7   取8字节(是最大字节int所占4字节的整数倍)
}mys1;
typedef struct mystruct2
{
	char a;  //0
	int b;   //4-7
	short c; //8-9   取12字节(是最大字节int所占4字节的整数倍)
}mys2;

int main()
{
	cout << sizeof(mys1) << endl;
	cout << sizeof(mys2) << endl;
}

2.2、结构体内部嵌套结构体或者联合体#

2.2.1、联合体说明

联合体中的各个成员都是从同一地址开始存储的，每一时刻只能存储一个成员，这样就需要在分配内存时满足两点：
(1)、共用体所占内存时其最大成员的大小
(2)、若是联合体内部最大成员所占的空间对其他成员不满足整数倍关系，则需要自动延伸，使得满足整数倍关系

union   mm {
	char   a;     // 1  
	int   b[5];  //  4 * 5 
	double   c;  //  8  
	int   d[3];  // 4 * 3
};

本来联合体mm所占内存大小应该是sizeof(int)*5 = 20字节，但是20字节和其中double的8字节不满足整数倍关系，所以mm所占的大小应该是24字节

2.2.2、结构体内部嵌套结构体

规则如下：
1、联合体或者结构体作为成员变量时，需要从其内部最大元素的整数倍开始存储
2、最终结构体所占字节大小需要是结构体中**最大变量(内部结构体中的最大变量)**的整数倍

#include <stdio.h>

//本来mm的空间应该是sizeof(int) * 5 = 20; 但是如果只是20个单元的话, 
//那可以存几个double型(8位)呢 ? 两个半 ? 当然不可以, 所以mm的空间延伸为既要大于20, 
//又要满足其他成员所需空间的整数倍, 即24
typedef union   mm {
	char   a;
	int    b[5];
	double   c;
	int   d[3];
}mm1;

typedef struct mystruct1
{
	int a;   //0-3
	char b;  //4
	short c; //6-7   取8字节(是最大字节int所占4字节的整数倍)
}mys1;
typedef struct mystruct2
{
	char a;  //0
	int b;   //4-7
	short c; //8-9   取12字节(是最大字节int所占4字节的整数倍)
}mys2;

typedef struct mystruct3
{
	int a;    //0-3
	mys1 s1;  //4-11     结构体成员要从其内部最大元素大小的整数倍地址开始存储
	double b; //16-23
	int c;    //24-27    取32字节(是最大字节double所占8字节的整数倍)
}mys3;

typedef struct mystruct4
{
	char sex;   //0
	int length; //4-7
	char name[10];  //8-17   取20字节(是最大字节int所占4字节的整数倍)
}mys4;

typedef struct mystruct5
{
	char s[5];  //4字节：0-4
	mys1 s1;    //8字节：8-15       mys1中最大字节为int 占4字节
	char a[12]; //12字节：16-27
	int b[3];   //12字节：28-39
	short c[3]; //6字节：40-45
	mys3 s3;    //32字节：48-79     mys3中最大字节为double 占8字节
}mys5;          // 取80字节(是mys3中最大字节double所占8字节的整数倍)

typedef struct mystruct6
{
	char s[5];  //4字节：0-4
	mys1 s1;    //8字节：8-15       mys1中最大字节为int 占4字节
	char a[13]; //12字节：16-28 
	int b[3];   //12字节：32-43
	short c[3]; //6字节： 44-49
	mys3 s3;    //32字节：56-87     mys3中最大字节为double 占8字节
}mys6;          // 取88字节(是mys3中最大字节double所占8字节的整数倍)

typedef struct mystruct7
{
	int a;    //0-3
	mys1 s1;  //4-11     结构体成员要从其内部最大元素大小的整数倍地址开始存储
	mm1 m1;  //占24字节: 16-39 
	double b; //40-47
	int c;    //48-53    取56字节(是最大字节double所占8字节的整数倍)
}mys7;

typedef struct mystruct8
{
	char s[5];  //4字节：0-4
	mys1 s1;    //8字节：8-15       mys1中最大字节为int 占4字节
	char a[17]; //17字节：16-32 
	mm1  m1;    //24字节：40-63 // 从其内部最大元素double的整数倍开始存储
	int b[3];   //12字节：64-75
	short c[3]; //6字节： 76-81
	char ss[11];//11字节：82-92
	mm1  m2;    //24字节：96-119
	mys3 s3;    //32字节：120-151    mys3中最大字节为double 占8字节
}mys8;          // 取152字节(是最大字节mys3中double所占8字节的整数倍)


int main(void)
{
	printf("sizeof(mys1)=%d.\n", sizeof(mys1));  //sizeof(mys1)=8.  
	printf("sizeof(mys2)=%d.\n", sizeof(mys2));  //sizeof(mys2)=12. 
	printf("sizeof(mys3)=%d.\n", sizeof(mys3));  //sizeof(mys3)=32.  
	printf("sizeof(mys4)=%d.\n", sizeof(mys4));  //sizeof(mys4)=20
	printf("sizeof(mys5)=%d.\n", sizeof(mys5));  //sizeof(mys5)=80.
	printf("sizeof(mys6)=%d.\n", sizeof(mys6));  //sizeof(mys6)=88.
	printf("sizeof(mys7)=%d.\n", sizeof(mys7));  //sizeof(mys7)=56.
	printf("sizeof(mys8)=%d.\n", sizeof(mys8));  //sizeof(mys8)=152.
	return 0;
}

3、pragma pack(n)的作用

pragma pack（n）用于设置指定对齐值大小， 若是自身对齐值 大于 指定对齐值，则选用指定对齐值。
注：自身对齐值大小就是变量所占内存大小

#include <stdio.h>

// 若是自身对齐值 大于 指定对齐值，则选用指定对齐值
#pragma pack(2) // 设置指定对齐值为2
struct data1
{
	char c;     // 0     
	int a;      // 2-5   
	int b;      // 6-9
	double d;   // 10-17
}; // 18字节
#pragma pack() // 恢复默认对齐值

struct data2
{
	char c;     // 0   
	int a;      // 4-7  
	int b;      // 8-11
	double d;   // 16-23
}; // 24字节

#pragma pack(4) // 设置指定对齐值为4
struct data3
{
	char c;     // 0     
	int a;      // 4-7   
	int b;      // 8-11
	double d;   // 12-19
}; // 20字节
#pragma pack() // 恢复默认对齐值

int main()
{
	printf("data1所占字节：%d\n", sizeof(struct data1));
	printf("data2所占字节：%d\n", sizeof(struct data2));
	printf("data3所占字节：%d\n", sizeof(struct data3));
}