【C语言】结构体详解

在c语言中除了像int，char，float，long，double等本身支持的、现成的类型，也有自定义类型，比如说结构体struct、联合体union、枚举enum，接下来我们详细说一下结构体类型

1.结构体类型的声明

1.1 结构体变量的创建和初始化

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

struct tag
{
	member - list;  //成员，一个或多个
}variable-list;  //变量名

看不明白没关系，我们来举个例子，比如一个学生

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

};//这里有分号，不能忘了

注意几点：

1.struct后面的student命名只要是符合语法的都可以

2.分号前面、反大括号后面的variable-list可以不在此处创建变量，后面再创建，在此处创建的话就是全局结构体变量，后面再创建的话就是局部的结构体变量，如下

#include <stdio.h>

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

};

int main()
{
	struct student s1;  //s1为局部变量
	return 0;
}

或者

struct student
{
	char name[20];
	int age;
	char sex[5];
	char id[20];

}s1;//s1为全局变量

这里很容易理解错误，误以为struct是变量类型，student是变量，其实并非这样

比如说你定义一个 int a；int是变量类型，a是变量，同理 struct student是结构体变量类型，s1才是结构体变量

再举个例子，比如一本书

struct book
{
	char name[20];//书名
	char author[20];//作者
	float price;//价格
    char id[10];//书号
}s2,s3,s4;

struct book是结构体变量类型，s2，s3，s4都是结构体变量，且是全局变量

当然也可以像下面这样定义，这时s2，s3，s4[5]是局部变量，s4[5]是结构体数组

#include <stdio.h>
struct book
{
	char name[20];//书名
	char author[20];//作者
	float price;//价格
    char id[10];//书号
};
int main()
{
	struct book s2;
    struct book s3;
	struct book s4[5];

	return 0;
}

变量创建好之后我们来进行初始化，以上面的struct book s2为例

struct book s2 = { "wodeshu","lingyangjiao",18.8,"A1010" };

结构体初始化写在{}里面，书名、作者，书号是字符串，就用""初始化，价格是float类型，就直接写，中间用逗号隔开，我上面初始化的内容都是我随便写的，这种初始化是按照顺序依次初始化

也可以不按顺序，比如下面的代码

struct book s3 = { .id = "B2020",.author = "lingyangjiao",.name = "woxiedeshu",.price = 19.9 };

不按顺序的话就要用一个点（.）操作符来找结构体成员，然后用 = 赋值就行了，中间用逗号隔开

如何将这些内容打印出来呢？接着往下看

#include <stdio.h>
struct book
{
	char name[20];//书名
	char author[20];//作者
	float price;//价格
	char id[10];//书号
};
int main()
{
	struct book s2 = { "wodeshu","lingyangjiao",18.8,"A1010" };
	printf("%s %s %f %s\n", s2.name, s2.author, s2.price, s2.id);
	return 0;
}

这是一种打印方法，用点（.）操作符： 结构体变量名.结构体成员

还有一种就是箭头（->）操作符： 结构体指针->结构体成员，如下，p是结构体指针

struct book* p = &s2;
printf("%s %s %f %s\n", p->name, p->author, p->price, p->id);

1.2 结构的特殊声明

在声明结构的时候可以不完全声明，叫匿名结构体类型

比如

//不匿名
struct s
{
	char c;
	int i;
	float f;
};

//匿名
struct 
{
	char c;
	int i;
	float f;
};

这样的话这个结构体没有名字，定义变量的时候就不可以像下面这样

struct s//正常情况
{
	char c;
	int i;
	float f;
};
struct //匿名情况
{
	char c;
	int i;
	float f;
};
int main()
{
	struct s S;//正常情况创建变量S
	struct S;//匿名结构体不可以这样创建S
	return 0;
}

应该像下面这样创建

struct //匿名情况
{
	char c;
	int i;
	float f;
}S;

同时可以对它进行初始化

struct //匿名情况
{
	char c;
	int i;
	float f;
}S = { 'x', 10, 3.14 };

打印出来看看

#include <stdio.h>
struct //匿名情况
{
	char c;
	int i;
	float f;
}S = { 'x', 10, 3.14 };
int main()
{
	printf("%c %d %f", S.c, S.i, S.f);
	return 0;
}

现在这个类型没有名字，匿名了，所以匿名结构体只能用一次 ，但不是销毁

现在我们来思考一个问题，下面的代码可以这样写吗？

#include <stdio.h>
struct 
{
	char c;
	int i;
	float f;
}s;
struct
{
	char c;
	int i;
	float f;
}* ps;
int main()
{
	ps = &s;
	return 0;
}

答案是不可以的，因为这个匿名结构体没有名字，编译器无法确认s和指针ps类型是否一致

所以，匿名结构体是可以用的，也是存在的，但是使用很局限

1.3 结构体的自引用

大家可能或多或少听说过链表

我们把每一个框称为一个节点，这个节点不仅携带了值，还需要携带能找到下一个节点的信息，所以要把这样一个节点分为两部分，一部分存放值，一部分存放下一个结点的信息

存放下一个结点的信息时，可以像下面这样吗？

struct Node
{
	int a;
	struct Node next;
};

答案是不可以。为什么不可以呢？想一下这样包含的话 sizeof(struct Node)的大小是多少呢？自己包含自己，无穷下去，最终能算出结构体大小吗？不能。那我们应该怎么做？

既然我们只是为了找到下一个节点，那我们存放下一个节点的地址就好了，最后一个节点放空指针NULL

struct Node
{
	int a;//数据
	struct Node* next;//指针，大小为4个字节
};

这样就实现了结构体自己包含自己，也就是结构体的自引用（匿名的结构体不能实现结构体的自引用）

2.结构体内存对齐

看下面的代码，s的大小是多少？

#include <stdio.h>
struct S
{
	char c1;
	int i;
	char c2;
};
int main()
{
	struct S s = { 0 };
	printf("%zd\n", sizeof(s));
	return 0;
}

char占1个字节，int占4个字节，char再占一个字节，大小为6，是不是呢？

显然不是，结果为12， 这是为什么呢？ 接下来我们就说说结构体的内存对齐

2.1 对齐规则

规则1

结构体的第一个成员对齐到结构体变量起始位置偏移量为0的地址处

规则2

其他成员要对齐到某个数字（对齐数）的整数倍的地址处

对齐数：编译器默认的对齐数 与 成员变量的大小的较小值

--vs默认对齐数是8

--Linux中gcc没有默认对齐数，所以对齐数就是成员自身大小

i的对齐数是4，从4的倍数的偏移量开始存4个字节，c2的对齐数是1，从1的倍数开始存1个字节

规则3

结构体总大小为结构体中所有成员对齐数的最大对齐数的整数倍

s中的成员最大对齐数是成员i的对齐数，为4，所以结构体的大小为4的倍数，当前大小为9，不是4的倍数，往后数，直到12，是4的倍数，所以结构体大小为12个字节，打红色X的空间都是被浪费掉的，为什么要浪费，我们后面讨论

对前三个规则的练习

1.算结构体大小

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

画图表示

结果是8个字节

2. 算结构体大小

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

依然是画图

为16个字节

3.算结构体大小，这里的struct s3就是上一题的struct s3

struct s4
{
	char c1;
	struct s3 S;
	double d;
};

还是画图

c1放好之后，嵌套的结构体S应该怎么放呢？我们先来看看第4个规则

规则4

如果结构体嵌套了结构体，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有对齐数的最大值（包括嵌套结构体的对齐数）的整数倍

S中的最大对齐数是8，所以S要对齐到8的倍数

那么这个结构体的大小是不是就是32呢？是的

2.2 为什么存在内存对齐

那么在设计结构体中，我们既要对齐，又节省空间的话，应该怎么做？

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

比如

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

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

虽然两个结构体成员完全一样，但是画图分析就可以知道内存区别

2.3 修改默认对齐数

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

没修改之前，下面这个代码结果应该为12，这个结构体的大小是12

#include <stdio.h>
struct S
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%zd", sizeof(struct S));
	return 0;
}

我们用 #pragma pack（n）修改默认对齐数，要修改的值n放在（）里

#include <stdio.h>
#pragma pack(1) //默认对齐数设为1
struct S
{
	char c1;
	int i;
	char c2;
};
#pragma pack() //取消修改，括号中不放数

int main()
{
	printf("%zd", sizeof(struct S));
	return 0;
}

结果应该是6

3.结构体传参

现在需要写一个函数来打印结构体里面的内容，这个函数应该怎么传参？参数应该怎么设计？

#include <stdio.h>
struct S
{
	int arr[1000];
	int n;
	double d;
};
int main()
{
	struct S s = { {1,2,3,4,5},100,3.14 };//初始化
	printf1();//负责打印的函数
	return 0;
}

看下面的函数可以实现吗

void printf1(struct S t) //传值
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", t.arr[i]); //打印数组
	}
	printf("%d ", t.n);//打印n
	printf("%lf ", t.d);//打印d
}

printf1(s);

当代码运行起来的时候是可以打印出来的

但是，这是传值调用，这意味着S有多大空间，t就有多大空间，一个数组arr[1000]就占了4000个字节，而这么多的内存还要开辟两次，可想而知，很浪费空间，并且浪费时间，那怎么传呢？传地址过去就好了

printf2(&s);

void printf2(struct S * t)
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", t->arr[i]); //打印数组
	}
	printf("%d ", t->n);//打印n
	printf("%lf ", t->d);//打印d
}

用结构体指针t接收s的地址，聪明的同学已经发现，t的类型改为结构体指针后，打印结构体的时候操作符也变了，从 点（.）操作符： 结构体变量名.结构体成员 变成了 箭头（->）操作符： 结构体指针->结构体成员

所以，结构体传参的时候尽量传地址，如果害怕传址调用函数会改变结构体的值，在*前加一个const修饰就好了

void printf2(const struct S * t)

4.结构体实现位段

4.1 什么是位段

位段是基于结构体的，位段的声明和结构类似，但有两点不同

1.位段成员必须是int（char）、unsigned int、signed int，在C99中位段成员类型也可以选项其他类型

2.位段成员名后面有一个冒号和数字，然后再加分号

比如

struct S1  //位段
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};

struct S2  //结构体
{
	int _a;
	int _b;
	int _c;
	int _d;
};

这就是位段式的结构 ，成员名命名合法即可，不一定要加下划线（_）

在结构体s2中，一个int占4个字节，32个bit位，假如现在我们在成员_a中存放的值只有0、1、2、3这样的数，一个数就只占了两个bit位，给_a 32个bit位的话会浪费30个bit位。

位段式s1中 int _a : 2; 这句的意思就是，_a只占两个bit位，同理，_b就只占5个bit位，_c占10个bit位，_d就占30个bit位

位段的应用场景就是这种，指定成员所占bit位，节省内存

那么s1的大小现在是多少字节呢？思考一下，我们稍后揭示

4.2位段的内存分配

1.位段的空间上是按照需要，以4个字节（int）或1个字节（char）的方式开辟的，不够用再开辟

2.位段有很多不确定因素，不可跨平台

我们先来看一段代码

#include <stdio.h>
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

为了演示我们一次一次开辟空间，首先开辟第一个成员char应该占的字节大小，1个字节

开辟好之后，位段中 a占3个bit位，从这4个字节的左边先使用还是右边呢？在vs中默认是从右向左使用，如图

然后就存放b，b占4个bit位，这一个字节还剩下5个bit位，够b使用，继续存放在这个空间中，如图

现在还剩1个bit位，c需要5个bit位，这个剩下的1个空间浪费还是继续使用？在vs中，会浪费这1个bit位，并且再申请一个字节空间，如图

现在第二个字节还剩3个bit位，而d需要4个字节，还是一样，把这3个浪费掉，重新开辟一个字节，如图

现在成员内存空间就开辟完了，我们一共申请了3个字节

现在开始存放数据

我们把s1初始化为0了，现在里面的每个bit位都是0，我们一个一个看，先看a

a赋值为10，10的二进制数后8个为 00001010，但是a的位置只有3个bit位，只能存3个，存的是后3位，也就是 010 ，如图

b赋值为12，12的二进制数后8个为 00001100 ，b只有4个bit位，所以存1100，如图

c赋值为3，2的二进制数后8个为00000011，c有5个bit位，所以存00011，如图

d赋值为4，4的二进制数后8个是00000100，d有4个bit位，所以存0100，如图

其余位置放0

4个二进制位换一个16进制位，所以最后的结果用16进制表示就是0x620304

0110 0010 0000 0011 0000 0100 //二进制
6    2    0    3    0    4    //16进制

我们打开调试窗口看对不对

结果完全正确

我们再回过头来看4.1中 s1 的内存

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

画图看看就可以知道，s1占了8个字节

本次分享就到这里，感谢阅读！