结构体详解

前言

在我们日常时候中有很多东西都不能用简单的用一个整型或一个字符串来表示的，比如，一个人有体重、身高、姓名、性别、年龄等等，再比如一本书，有书名、价格、作者、出版社等等，描述这些复杂事物我们就可以用结构体来解决。（以下代码均在VS2019，X86下运行）

结构体的声明

结构的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构体的声明

例如描述一个学生：

struct Stu     //struct Stu是结构体变量的类型
{
	char name[20];  //名字
	int age;  //年龄
	char sex[5];  //性别
	char id[20];  //学号
};   //分号不能丢
1
2
3
4
5
6
7

我们还可以这样定义：

struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
}s1,s2;        //声明一个结构体并定义两个该结构体类型变量，s1、s2是全局变量
int main()
{
    struct Stu s3;  //s3是局部变量
    struct Stu s4;  //s4是局部变量
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

特殊的声明

在声明结构体的时候，可以不完全的声明。
例如：

//匿名结构体类型，不知道结构体的具体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;
1
2
3
4
5
6
7
8
9
10
11
12
13

上面的两个结构体在声明的时候省略掉了结构体标签。
那么问题来了，在上面代码的基础上，下面的代码合法吗？

	p = &x;   
1

警告：
编译器不知道结构体的具体类型，所以会把上面的两个声明当成完全不同的两个类型。
所以是非法的。

注意：匿名结构体要定义变量只能跟在结构体后面定义。

struct
{
	int a;
	char b;
	float c;
}x;      //可以
int main()
{
	struct y;   //不行
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

结构体的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

struct Node
{
	int data;
	struct Node next;
};
1
2
3
4
5

这样定义可以吗？
如果可行，那sizeof(struct Node)为多大？

这样不行，我们看到 struct Node 类型的结构体里定义了一个结构体 next，该结构体类型里包含了一个 int 类型和一个结构体类型，这个结构体里又有结构体……
这样无限套娃，没有停止，占用的空间无限大，这是不行的。

那我们如何来正确的自引用呢？

struct Nod
{
	int data;
	struct Nod* next;  //定义一个该结构体的指针，解引用即可得到该结构体
};       
int main()
{
	struct Nod n;    //每次定义一个结构体都要写 struct ，有没有什么办法可以不用写呢？
	return 0;
}
1
2
3
4
5
6
7
8
9
10

我们可以这样写：

typedef struct Nod 
{
	int data;
	struct Nod* next;  
}Node;      //对前面的结构体重命名，取名为 Node
int main()
{
	Node n;   
	return 0;
}
1
2
3
4
5
6
7
8
9
10

我们再来看看下面代码：

typedef struct Nod
{
	int data;
	Node* next;   //在结构体内部用Node不行，因为在结构体内部时还未重命名为 Node
}Node;
1
2
3
4
5

typedef struct Nod
{
	int data;
	struct Nod* next;    //应该这样写
}Node;
1
2
3
4
5

结构体变量的定义和初始化

有了结构体类型，那如何定义变量呢？

struct Point
{
	int x;
	int y;
}p1;       //声明类型的同时定义变量 p1
struct Point p2;   //定义结构体变量 p2
struct Point p3 = { 2, 4 };    //定义变量的同时赋初值。
1
2
3
4
5
6
7

struct Stu   //类型声明
{
	char name[15];  //名字
	int age;   //年龄
};
struct Stu s = { "zhangsan", 20 };  //初始化
1
2
3
4
5
6

struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化
struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化
1
2
3
4
5
6
7

结构体内存对齐

我们来思考一个问题：如何计算结构体的大小？

struct S1
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%d\n", sizeof(struct S1));   //大小为多少呢？
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

输出：12
为什么呢？
别急我们先来了解一下结构体的对齐规则：

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

我们来分析一下：

struct S1
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%d\n", sizeof(struct S1));  
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

我们可以做出下图：

从偏移量为0的地址处开始存放数据，第一个是 char 型，默认对齐数是8，1与8相比1小，对齐到1的整数倍0处，然后是 int 型，4与8比较4小，于是对齐到4的倍数处，即偏移量为4处（1、2、3处内存均被浪费了），然后是 cahr 型，对齐到偏移量为8处，存放完数据后发现总共占用了9个字节的空间，9不是4的倍数，于是扩大到12，即偏移量为11处（9、10、11处内存被浪费了）。

再来一道例题：

struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S2));  
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

输出：8
原理和上题一样，多思考思考。
再来下题：

struct S3
{
	double d;
	char c;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S3));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

输出：16
注意：double 类型占用8字节的空间。
来个结构体嵌套问题：

struct S3
{
	double d;
	char c;
	int i;
};
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%d\n", sizeof(struct S4));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出：32
画一画图就能解出了，解题关键在内存对齐规则4处，认真阅读，这里就不再分析了。

我们来思考个问题：为什么存在内存对齐？

1. 平台原因(移植原因)：
   不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。（比如：int型数据读取只能在偏移量为4的倍数处读取）
2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

第二点什么意思呢？

我们来举个例子就知道了：

struct S
{
	char c;
	int i;
};
struct S s;
1
2
3
4
5
6

我们针对两种不同对齐方式做出下图：

以32位为例，一次读取4个字节
不对齐：读取数据 c 的时候，一次读取4个字节，很明显 c 被读取出来了，如果读取数据 i 呢？
首先从左边开始读取4个字节数据，但是我们发现一次读取似乎不能读完 i 的内容，需要再读一次，如图：

对齐：对齐情况如图：

读取数据 c 时，读取一次即可，读取数据 i 时，读取一次即可。
这样大大减少了时间，但是也浪费了空间。
由此：

结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占用空间小的成员尽量集中在一起。

例如：

struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};
1
2
3
4
5
6
7
8
9
10
11
12

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。
S2占用空间更小。

修改默认对齐数

我们先来了解下 #pragma 这个预处理指令，这个指令可以改变我们的默认对齐数。
例如：

#include <stdio.h>
#pragma pack(8)  //设置默认对齐数为8
struct S1
{
	char c1;
	int i;
	char c2;
}s1;
#pragma pack()  //取消设置的默认对齐数，还原为默认
1
2
3
4
5
6
7
8
9

s1占用内存大小为12字节

#pragma pack(1)//设置默认对齐数为1
struct S2
{
	char c1;
	int i;
	char c2;
}s2;
#pragma pack()//取消设置的默认对齐数，还原为默认
1
2
3
4
5
6
7
8

s2占用内存大小为6字节

结论：结构体在对齐方式不合适的时候，我么可以自己更改默认对齐数。

结构体传参

直接上代码：

struct S
{
	int data[1000];
	int num;
};
struct S s = { {1,2,3,4}, 1000 };
 //结构体传参
void print1(struct S s)
{
	printf("%d\n", s.num);
}
 //结构体地址传参
void print2(struct S* ps)
{
	printf("%d\n", ps->num);
}
int main()
{
	print1(s); //传结构体
	print2(&s); //传地址
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。

原因：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。(就是传递结构体的时候形参会临时拷贝一份该结构体，浪费了大量空间，传递地址效率更高)

结论：结构体传参的时候，要传结构体的地址。