C语言进阶笔记（七） | 自定义类型1 结构体（详解）

目录

结构体的声明

结构体声明及使用

特殊的声明

结构体的自引用 

错误的自引用

正确的自引用

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

结构体内存对齐

计算结构体的大小

结构体的对齐规则

存在内存对齐的原因

修改默认对齐数

结构体传参

---

常见自定义类型

结构体

枚举

联合体

已经知道数组是相同类型元素的集合，
而结构体也是一些值的集合，结构的每个成员可以是不同类型。

结构体的声明

例如：描述一本书

struct Book//struct - 结构关键词  Book - 结构体标签名  struct Book - 结构体类型
{
    //结构体成员
    char name[20];
    int price;
    char id[12];
};

结构体可以在声明时直接创建变量，也可以在主函数中创建变量。

结构体声明及使用

struct Book
{
	char name[20];
	int price;
	char id[12];
}b1,b2;//结构体使用 - 创建全局变量b1,b2

int main()
{
	//结构体使用 - 创建局部变量b3,b4
	struct Book b3;
	struct Book b4;
}

特殊的声明

在声明结构的时候，可以不完全的声明。

匿名结构体类型 - 不写结构体标签 - 有局限性，只能用一次。

#include

struct
{
	char c;
	int i;
	double d;
}s;//直接用匿名结构体类型创建一个变量

struct
{
	char c;
	int i;
	double d;
}*ps;

int main()
{
	ps = &s;//err  警告：编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。
	return 0;
}

结构体的自引用 

在结构中包含一个其他结构体类型的成员是否可以呢？

struct A
{
	int i;
	char c;
};

struct B
{
	char c;
	struct A sa;
	double d;
};

结构体B包含结构体A是可行的。

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

错误的自引用

下面代码是否可行？
如果可以，那sizeof(struct Node)是多少？

struct Node
{
    int data;
    struct Node next;
};

计算上面结构体大小我们发现会无限递归，无限大，是不可行的。

正确的自引用

那么结构体的自引用是不可行的吗？不，结构体正确的自引用应该写成下面形式。

struct Node
{
    int data;
    struct Node* next;
};

结构体正确的自引用应该是结构体包含同类型的结构体指针，它可用于链表（一种线性数据结构，后面会学到）的实现。

注意：

这样的代码是否可行？

typedef struct
{
	int data;
	N* next;   
}N;

答案是不可行的。N被重定义了才可以用，而结构体确定了才可以重定义为N，相互矛盾。

解决方案如下：

typedef struct N
{
 int data;
 struct N* next;//上面有了struct N，所以可以用。
}N;

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

有了结构体类型，怎么定义并结构体类型变量并初始化呢？其实很简单，之前的笔记博文也已经涉及到过了，这里直接上代码。

struct P
{
    int x;
    int y;
}p1; //声明类型的同时定义变量p1

struct P p2; //定义结构体变量p2

#include

struct S
{
	char c;
	int i;
};

struct B
{
	double d;
	struct S s;
	char c;
};

int main()
{
	//定义变量的同时并初始化
	struct S s1 = { 'a',10 };
	struct B b1 = { 3.14,{'b',20},'c' };//结构体嵌套初始化
	//结构体变量 b1 的打印
	printf("%lf %c %d %c\n", b1.d, b1.s.c, b1.s.i, b1.c);//3.140000 b 20 c

	return 0;
}

结构体内存对齐

我们都已经知道int、char、float等类型的大小，那结构体的大小怎么计算呢？

这里也是一个特别热门的考点： 结构体内存对齐

计算结构体的大小

大家觉得下面结构体的大小是多少呢？

struct S1
{
	int i;
	char c;
};

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

结构体S1中，int i为4个字节，char c为1个字节，大家是否就认为结构体S1的大小为5个字节呢？

结构体S2中，char c1为1个字节，int i为4个字节，char c2为1个字节，大家是否就认为结构体S2的大小为6个字节呢？

然而并不是，通过下面代码的输出结果，我们会发现，结构体S1大小为8个字节，结构体S2大小为12个字节。

#include

struct S1
{
	int i;//4
	char c;//1
};

struct S2
{
	char c1;//1
	int i;//4
	char c2;//1
};

int main()
{
	struct S1 s1 = { 0 };
	printf("%d\n", sizeof(s1));//8

	struct S2 s2 = { 0 };
	printf("%d\n", sizeof(s2));//12

	return 0;
}

这里就涉及到了结构体的内存对齐问题了。

要计算结构体的大小，首先得掌握结构体的对齐规则。

结构体的对齐规则

1. 第一个成员在与结构体变量偏移量为0（即结构体开始的地方）的地址处。

2. 其他成员变量要对齐到偏移量为对齐数整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。(VS中默认的对齐数为8)

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

这些规则是什么意思呢？拿下面结构体S举例介绍

struct S
{
	char c1;//1
	int i;//4
	char c2;//1
};

与结构体的偏移量指的是，每个字节内存空间距离结构体开始处的字节个数。

假设内存中结构体S位置如下图

首先，第一个成员在与结构体变量偏移量为0（即结构体开始的地方）的地址处。

那么结构体S中第一个成员c1位置应该如下

接着，其他成员变量要对齐到偏移量为对齐数整数倍的地址处。 

对于结构体S中第二个成员i，自身大小为4个字节，VS默认对齐数为8，对齐数取两者较小值，即4。那么 i 的位置应该如下

 对于结构体S中第三个成员c2，自身大小为1个字节，VS默认对齐数为8，对齐数取两者较小值，即1。那么 c2 的位置应该如下

 那么，结构体S的大小就是9个字节吗？NO！结构体内存对齐还有一条是

结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

结构体S的最大对齐数是4，S的大小需要补到12，即结构体S在内存中所占空间应该如下

（打×的为浪费不用的内存空间）

 所以结构体S的大小为12个字节。

练习

#include

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

struct S2
{
	double d;
	char c;
    int i;
};

struct S3
{
	char c1;
	struct S2 s2;
};

int main()
{
	struct S1 s1 = { 0 };
	struct S2 s2 = { 0 };
	struct S3 s3 = { 0 };

	printf("%d\n", sizeof(s1));
	printf("%d\n", sizeof(s2));
	printf("%d\n", sizeof(s3));

	return 0;
}

上面结构体大小打印结构分别为12 16 24

 其中结构体S3为嵌套结构体，而

如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

 所以结构体S3在内存中的分布如下

存在内存对齐的原因

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

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

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

那在设计结构体的时候，我们为了既要满足对齐，又要节省空间，要让占用空间小的成员尽量集中在一起。如下

struct S1
{
	char c1;
	int i;
	char c2;
};//12个字节
struct S2
{
	char c1;
	char c2;
	int i;
};//8个字节

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

修改默认对齐数

修改默认对齐数，要用#pragma 这个预处理指令

#include

//默认对齐数是8
struct S
{
	char c1;
	int i;
	char c2;
};

#pragma pack(2)//把默认对齐数改为2

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

#pragma pack(1)//把默认对齐数改为1

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

#pragma pack()//取消修改

int main()
{
	printf("%d\n", sizeof(struct S));//12
	printf("%d\n", sizeof(struct S1));//8
	printf("%d\n", sizeof(struct S2));//6

	return 0;
}

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

结构体传参

直接上代码

#include

struct S
{
	int data[1000];
	int num;
};

struct S s = { {1,2,3}, 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;
}

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，会导致性能的下降。

print1会对结构体临时拷贝，结构体较大时，浪费时间、空间；
且有局限性，要改变变量时，改变的只是临时拷贝，不能改变结构体变量。

所以print2更好，结构体传参的时候，要传结构体的地址。
用指针传参时，若不想改变结构体变量，可在形参前加const。