一、 掌握结构体的对齐规则

1、第一个成员在与结构体变量偏移量为0的地址处。
2、其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数=编译器默认的一个对齐数与该成员的大小进行比较得出的较小值
vs(博主使用的编译器)中默认为8 gcc当中没有默认对齐数，此时对齐数为成员变量大小。
3、结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4、如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

二、例子分析

代码显示：

struct S1
{
	char c1;//第一个成员变量，在与s1变量偏移量为0的地址处
	int a;//int 类型内存大小为4，与8相比，4位第二个成员变量的对齐数，在与s1变量偏移量为4的整数倍的地址处
	char c2;//第三个成员变量，char类型 内存大小为1，与8相比，对齐数为1，在与s1偏移量为1的整数倍的地址处
	//最后结构体的总大小为最大对齐数即（1,4,1）中最大数4的整数倍
};
struct S2
{
	char c1;
	char c2;
	int a;
};
int main()
{
	struct S1 s1 = { 0 };
	printf("%d\n", sizeof(s1));//计算结构体变量s1的内存大小
	struct S2 s2 = { 0 };
	printf("%d\n", sizeof(s2));//计算结构体变量s2的内存大小
	return 0;
}

结果：

（1）s1的计算过程：

如图，变量s1在内存中开辟一个空间，c1是第一个成员变量，在与结构体变量为0的地址处（红色区域为c1所占内存空间）。a为s1的第二个成员变量（int 类型），它的大小为4字节，对齐数为4（与8比较），位于与s1偏移量为4（4的整数倍）的地址处（紫色区域），c1与a之间的空白为浪费的空间。c2的对齐数为1，它在与s1偏移量为9（1的整数倍）的地址处（粉色区域），因为现在的结构体大小为9，而结构体的总大小要为最大对齐数（4）的整数倍，所以我们还要浪费三个字节的空间，因此此时s1的总大小为12字节。
（2）s2的计算过程：

如图，变量s2在内存中开辟一个空间，c1是第一个成员变量，在与结构体变量为0的地址处（红色区域为c1所占内存空间）。c2为s1的第二个成员变量（char类型），它的大小为1个字节，对齐数为1（与8比较），位于与s1偏移量为1（1的整数倍）的地址处（绿色区域）。a的对齐数为4(与8比较)，它在与s1偏移量为4（4的整数倍）的地址处（紫色区域），c2与a之间的空白为浪费的空间，因为现在的结构体大小为8，是最大对齐数（4）的整数倍，所以此时s2的总大小就为8。

嵌套结构体变量

代码显示：

struct S3
{
	double d;//8
	char c;//1
	int i;//4
};

struct S4
{
	char c1;//1
	struct S3 s3;//对齐数为S3中各对齐数的最大对齐数即max（8，1,4）
	double d;//8
};




int main()
{
	struct S3 s3 = { 0 };
	printf("%d\n", sizeof(s3));//计算结构体变量s3的内存大小
	struct S4 s4= { 0 };
	printf("%d\n", sizeof(s4));//计算嵌套结构体变量s4的内存大小
	return 0;
}

结果：

（3）s3的计算过程:

如图，变量s3在内存中开辟一个空间，d是第一个成员变量，在与结构体变量为0的地址处（红色区域为d所占内存空间）。c为s3的第二个成员变量（char类型），它的大小为1个字节，对齐数为1（与8比较），位于与s3偏移量为8（1的整数倍）的地址处（绿色区域）。i的对齐数为4(与8比较)，它在与s3偏移量为12（4的整数倍）的地址处（蓝色区域），紫色区域为浪费的空间，因为现在的结构体大小为16，是最大对齐数（8）的整数倍，所以此时s3的总大小就为16。

（4）嵌套结构体变量s4的计算：

如图，变量s4在内存中开辟一个空间，c1是第一个成员变量，在与结构体变量为0的地址处（蓝色区域为c1所占内存空间）。s3为s4的第二个成员变量（结构体 类型），s3的对齐数为s3中所有对齐数中最大的对齐数（即max(8,1,4)）8，位于与s4偏移量为8（8的整数倍）的地址处（绿色区域）。红色区域为浪费的空间。d的对齐数为4(与8比较)，它在与s4偏移量为24（4的整数倍）的地址处（紫色区域），因为现在的结构体大小为32，是最大对齐数（8）的整数倍，所以此时s4的总大小就为32。

1,结构体是一种自己定义的数据类型；是创建变量的模板；不占有内存空间；结构体变量才包含数据存储的空间；
2，结构体与数组相似但数组中的数据类型全部相同，结构体中的数据类型不一定相同；
3,结构体变量在内存中的位置关系（不考虑内存对齐的问题）

#include
struct Student
{
 char s_id[8];
 char s_name[8];
 char s_sex[5];
 int s_age;
}Student;
int main()
{
int a=10,b=20;
Student s1={"10906","ljl","man","18"};
return 0;
}
内存分布如下

#include<stdio.h>
struct Student
{

注意vs2019不支持(vs2012支持)
 char *s_id;
 char *s_name;
 char *s_sex;
 int *s_age;


 2019应写为
 const char *s_id;
 const char *s_name;
 const char *s_sex;
 int s_age;
}Student;
int main()
{
int a=10,b=20;
Student s1={"10906","ljl","man","18"};
return 0;
}
内存分布如下

4,结构体的自定义会导致程序崩溃

5，结构体的嵌套

#include<stdio.h>
#include<string.h>
struct Date
{
int year;
int month;
int day;
};
struct Student
{
 char s_id[8];
 char s_name[8];
 cahr s_sex[5];
 struct Date brithday;
 int s_age;
}Student;
int main()
{
int a=10,b=20;
Student s1={"10906","ljl","man",{1999,07,08},"18"};
或者不加{}
Student s1={"10906","ljl","man",1999,07,08,"18"};
return 0;
}

6.相同的结构体变量可以相互赋值

#include<stdlib.h>
#include<string.h>
struct Student
{
 char s_id[8];
 char s_name[8];
 cahr s_sex[5];
 int s_age;
}Student;
int main()
{
int a=10,b=20;
Student s1={"10906","ljl","man","18"};
Student s2,s3;
s2=s1;
s3=s2;


但是不可以进行以下操作(数组不可以相互赋值)
s2.s_id=s1.s_id;


strcpy_s(s2.s_id,s1.s_id);
return 0;
}

结构体为什么要采用对齐方式：
1，cpu并非逐字节的读写内存而是以2，4，或8的倍数的字节快来读取
例如：有一个int类型从三字节开始存放，cpu以2的倍数访问就需要4次才可以读取完该int类型的变量；

2，有些平台每次读都是从偶地址开始，如果一个int型(假设为32位系统)如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit,而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。
3，不同的平台采用的对齐方式可能就会不同，因此同样的结构体在不同的平台可能大小也不相同；

计算结构体大小的三条规则：
1，结构体变量的首地址必须是结构体变量中最大的基本数据类型所占字节的整数倍；
2，结构体中的每个成员相对于结构体首地址的偏移量都必须是每个变量本身基本数据类型所占字节个数的整数倍；
3，结构体变量的总大小为结构体中最大变量其基本数据类型所占字节数的整数倍；
例如：
1，大小 为12

struct node
{
char a;
int b;
char c;
};

2，大小为24

struct node
{
 char a;
 double b;
 char c;
};

3，大小为8

4,结构体的嵌套大小为40

注意上图中最大基本类型仍为8，在处理birthday时应偏移量与data结构体中的最大类型
5，结构体大小为48

6，结构体大小为80

7，计算结构体成员的偏移量

允许设计结构体变量

#include <stdio.h>
struct Eemployr
{
char a[27];
char b[30];
long int c;
long int d;
double e;
};
int main()
{
struct Eemployr s;
int offer=(char*)&s.d-(char*)&s;
printf("%d",offer);
return 0;
}
打印结果为64


不允许设计结构体变量
#include <stdio.h>
struct Employr
{
char a[27];
char b[30];
long int c;
long int d;
double e;
};
int main()
{
将0强转为结构体指针类型在指向d之后再将其地址强转为整型；
int offer=(int)&((struct Employr *)0)->d;
printf("%d",offer);
return 0;
}
打印结果为64



#define(type,exa)  ((int)&((struct *)0)->exa)

原文链接：http://blog.sina.com.cn/s/blog_75a2ecd20102xca0.html

一个结构体变量占多大内存空间的问题

直接来看相同数据结构体的几种书写的格式吧。

格式一：

1.  struct tagPhone    

2.  {    

3.       char   A;    

4.       int    B;    

5.       short  C;    

6.  }Phone1;  

格式二：  

1.  struct tagPhone    

2.  {    

3.       char   A;    

4.       short  C;    

5.       int    B;    

6.  }Phone2;   

格式三：  

1.  struct tagPhone3    

2.  {    

3.       char    A;    

4.       char   B[2];    

5.       char    C[4];    

6.  }Phone3;   

格式四：

1.  struct tagPhone3    

2.  {    

3.       char    A;    

4.       double  B[2];    

5.       char    C[4];    

6.  }Phone4;   

例题：请问下面定义的结构体变量aa在计算机内存中占用多少字节？

#include

main()

{

struct  student

{   float    height;

short int  age ;

char     sex ;

}aa;

printf("%d\n",sizeof(aa));  //屏幕上将显示多少？

}

错误解答：我们都知道，char类型占用1个字节，float型占用4个字节，short int类型占用2个字节，int型在VC6.0中占用4个字节（TC2.0中占用2个字节），long占用8个字节，double占用8个字节。因此，我们可能会犯一个错误就是直接4+2+1=7，结构体aa占用7个字节。这是错的。

错误分析：计算结构体大小时需要考虑其内存布局，编译系统为了提高计算机访问数据的效率，在安排结构体每个成员的时候采用了内存对齐的方法，具体是：结构体在内存中的存放按单元进行存放，每个单元的大小取决于结构体中最大基本类型的大小。

对格式一：

图1

​​​​因为所有成员中B成员类型最大（int型占用4个字节），故结构体Phone1在内存分布时以4字节为一个单元来存储每个成员。又因为A占用一个字节后，只剩下3字节了，放不下后面紧挨的成员B了，所以必须开辟一个新的单元来存放B，B刚好占满一个单元，接下来的成员C又必须再开辟一个新的单元来存放。这样，Phone1占用的字节数就是：3*4=12；

同理对于格式二，

​

图2

A后面还有三个字节，足够存放C，所以C就放在了A的后面，然后只剩下一个字节了，不够存放后面的B，于是又开辟一个新单元存放B。这样，Phone2占用的内存字节就为2*4=8。

对于格式三： 

 图3

​上面结构体中，最大数据类型是char，占一个字节，因此它的一个存储单元就是1个字节。sizeof(Phone3) =1 + 2 + 4 = 7， 其大小正好是结构体中各成员所占内存空间之和，这种情况也是最节省存储空间的。

对于格式四：

图4

​Phone4中最大的数据类型是double，占8个字节，因此它的一个存储单元就是8个字节。由上图可知sizeof(Phone4)=4*8=32。

综上所述，格式一和格式四是非常浪费存储空间的，应该尽力避免；格式三对存储空间的利用率是最高的；格式二存储空间的利用率居中。作为一个优秀的程序员，应该深入掌握这些写法的差异性，以便视情况选用不同的写法。