自定义类型：结构体

前言：

在c语言中有两大类，分别是内置类型和自定义类型。今天我们来学一学一种自定义类型：结构体。

一、结构体

c语言中提供的内置类型，如：int、char、short、long、float、double、等等。但是这些内置类型往往是单一的，如描述一个学生时要有姓名、年龄、学号、等。c语言为解决这个问题增加了结构体这种自定义的数据类型，让程序员自己创造合适的类型。

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：
标量、数组、指针，甚⾄是其他结构体。

1.结构体的声明

struct tag
{
	member_list;
} variable_list;

当我们描述一个学生的时候

struct stu
{
	char name[20]; //姓名
	int age; //年龄
	char sex[5]; //性别
	char id[20]; //学号
}

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

// 1.变量的定义
struct point
{
	int x;
	int y;
}p1;  //声明类型的同时定义变量p1
struct point p2;  //定义结构体变量p2

// 2. 初始化
struct point p3 ={10,20}

struct stu  //类型声明
{
	char name[15];
	int age;
};
struct stu s1={"zhangsan"，20};//初始化
struct stu s2={.age=20;.name=""lisi};//指定顺序初始化

// 3. 

struct Node
{
	int date;
	struct point p;
	struct Node* next; 
}n1={10,{4,5},NULL}; //结构体嵌套初始化

struct Node n2={20,{5,6},NULL};

举例

#include<stdio.h>
struct stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
} 
int main()
{
	//按照结构体成员的顺序初始化
	struct stu s={"张三","20","男","20230021091"};
	printf("name:%s\n",s.name);
	printf("age:%d\n",s.age);
	printf("sex:%s\n",s.sex);
	printf("id:%d\n",s.id);

	//按照指定的顺序初始化
	struct stu s2={.age=18,.name="lisi",.sex="男",.id="20230021091"};
	printf("name:%s\n",s2.name);
	printf("age:%d\n",s2.age);
	printf("sex:%s\n",s2.sex);
	printf("id:%d\n",s2.id);
	
	return 0;

}

二、结构成员访问操作符

1.结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。

#include <stdio.h>
struct Point
{
	int x;
	int y;
}p={1,2};

int main()
{
	printf("x=%d y=%d",p.x,p.y)
}

结构体变量.成员名

2.结构体成员的间接访问

当我们得到一个结构体指针的时候，就需要结构体成员的间接访问。

#include <stdio.h>
struct point
{
	int x;
	int y;
};
int main()
{
	struct point p={3,4};
	struct point *ptr =&p;
	prt ->x=10;
	prt ->y=20;
	printf("x=%d y=%d\n",ptr->x,ptr->y);
	return 0;
}

三、结构的特殊声明

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

//匿名结构体函数
struct
{
	int a;
	char b;
	float c;
}x
struct 
{	
	int a;
	char b;
	float c;
}a[20],*p;

上面两个结构体都省略了结构体的标签。
在上面代码上，p=&x；这个代码合法吗？
非法的，编译器会把上面的两个声明当成完全不同的两个类型。
注意：匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使用一次。

四、结构的自引用

在结构中包含一个类型为该结构体本身的成员。

struct node
{
	int date;
	struct node next;
};

如果这样写的话那这个代码一直嵌套嵌套，这个结构体变量就会无穷的大。所以这个代码是不对的。

正确自引用：

struct node
{	
	int date;
	struct node* next; 
}

当我们自引用的时候，夹杂了typedef对匿名结构体类型重命名，也会出现问题。

typedef struct
{
	int date;
	node* next;
}node;

定义结构体不要使用匿名结构体

typedef struct node
{
	int date;
	struct node* next;
}node；

四、结构体内存对齐

1.对齐规律

结构体的对齐规则：
1.结构体的第一个成员对齐到结构体变量起始位置偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整倍数的地址处。
对齐数=编译器默认的一个对齐数与该成员变量大小的较小值。
（vs中默认值为8。Linux中gcc没有默认对齐数，对齐数就是成员自身的大小）
3.结构体总大小为最大对齐数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的整倍数。
4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

下面举例子进行具体说明

在这里插入代码片struct S1
 {
 char c1;
 int i;
 char c2;
 };
 printf("%d\n", sizeof(struct S1));

这段代码打印出来是9。根据上面结构体的对齐规律第一个成员对齐到结构体变量起始位置偏移量为0的地址处，所以char c1对齐为一个字节。然后是int i，int i是4个字节根据结构体的对齐规律‘一个对齐数与该成员的变量大小的较小值’。4个字节和8个字节比较小的是4所以对齐数要是4的倍数，int i对齐偏移量为8的地址。然后是 char c2，对齐数应该是一的倍数所以存入下一个偏移量地址8的位置。

下面是一个结构体嵌套的代码。

struct S3
 {
 double d;
 char c;
 int i;
 };
 printf("%d\n", sizeof(struct S3));
 
struct S4
 {
 char c1;
 struct S3 s3;
 double d;
 };
 printf("%d\n", sizeof(struct S4));

struct s3 结构体打印出来是16。和上一题一样，char c1放在偏移量为0的地址处。然后是结构体strct s3，根据结构体的对齐规则， 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

2.为什么存在对齐函数？

2.1平台原因（移植原因）

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

2.2性能原因

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两
个8字节内存块中。
结构体的对齐是拿空间来换取时间的做法

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

s1结构体和s2结构体类型成员是一模一样的，但是s1和s2的所占空间的大小有一些区别。

2.3修改默认对齐数

#pragma 这个预处理指令，可以改变编译器的默认对齐数。

#include<stdio.h>
#pragma pack(1)//设置默认对齐数为1
struct S
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的对其数，还原为默认
int main()
{
	printf("%d\n",sizeof(struct S));
	return 0;
}

这里打印出来是6，因为我们设置默认对齐数是1所有当int i对齐时，从偏移量一开始不需要对齐偏移量为4的倍数的地址。

3.结构体传参

 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()
 {
 	printf(s);
 	printf2(&s);
 	return 0;
 }

这两种传参方式首选是print2函数。
原因：
1.函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
2.如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的系统开销⽐较⼤，所以会导致性能的下降。

所以当结构体传参时，要传结构体的地址。

4.结构体实现位段

4.1什么是位段

位段的成员必须是int、unsigned int、signed int，在c99中位段成员的类型也可以选择其他类型。
位段成员后边有一个冒号和一个数字。

 struct A
 {
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
 };

A是一个位段类型。
内存占8个字节。

4.2位段的内存分配

1. 位段的成员可以是int、unsigned int 、signed int 或者是char 等类型。
2. 位段的空间上是按照需要以4个字节（int ）或者1个字节（char ）的⽅式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

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

4.3位段的跨平台问题

int 位段被当成有符号数还是⽆符号数是不确定的。
2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。
跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

4.4位段的应用

在⽹络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要⼏个bit位就能描述，这⾥
使⽤位段，能够实现想要的效果，也节省了空间，这样⽹络传输的数据报⼤⼩也会较⼩⼀些，对⽹络的畅通是有帮助的。

4.5位段使用的注意事项

位段的⼏个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。
所以不能对位段的成员使⽤&操作符，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员。

1
 2
 struct A
 {

 int _a : 2;
 int _b : 5;
 int _c : 10;
 int _d : 30;
 };
 int main()
 {
 struct A sa = {0};
 scanf("%d", &sa._b);//这是错误的
 
//正确的⽰范
 
int b = 0;
 scanf("%d", &b);
 sa._b = b;
 return 0;
 }

这些就是关于结构体的知识点了。