C语言初识结构体_类结构体怎么命名

结构体到底是什么？

通俗的讲：描述一个复杂对象的时候就需要创建结构体，例如描述一个学生{姓名，年龄，性别，成绩}等的相关信息.

在我们之前C语言学习到的类型有：
char     字符型
short    短整型
int      整型
long     长整型
float    单精度浮点型
double   双精度浮点型
【注】即使我们知道了这些类型，但是他们并不能表示世界上所有的东西，这些类型都是一些孤立的类型，每个类型表示一种含义。他们都可以创建对象这是毋庸置疑的，但是我们生活中存在一些复杂的对象，比如说“人”。

例：学生就是一个复杂对象
  在描述学生这个对象的时候不能单纯说他是哪个类型，因为学生有名字、年龄、性别、成绩…
名字：是一个字符串，想要描述这个字符串就需要把他放到字符数组中去。
年龄：是一个整数，想要存储年龄就需要一个整型的变量
性别：是一个字符串，男 、女、保密，想要描述这个字符串就需要把他放到字符数组中去
成绩：是一个浮点数，想要存储年龄就需要一个整型的变量

  所以在描述这样一个复杂对象的时候我们至少需要集合上面这四个成员，将他们整合在一起才能描绘出一个学生的复杂对象。

  那么如何将这些成员组合在一起构成一个复杂对象呢？这就有了结构体的概念。

1.结构体类型的声明

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

1.1结构的声明

结构体关键字是struct，别问为什么，这是语法规则

结构体的基本框架：
struct tag //tag是结构体标签
{
	member-list; //member-list是成员列表 

}; variable-list; //variable-list变量列表
1
2
3
4
5
6

代码实现：

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[8];//性别
	float score;//分数
}s1,s2,s3;//s1,s2,s3是 通过struct Stu类型创建的变量，这里的变量可以写一个，可以写多个，也可以不写
//此时创建的s1,s2,s3是全局变量

int main()
{
	//声明好struct Stu结构体后，还可以直接在main函数中创建结构体变量d4,s5
	//struct Stu 才是结构体类型，不能随便省略struct
	struct Stu s4;
	struct Stu s5;
	//这里的s4,s5是局部变量
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对应关系：

1.2结构体的重命名

如果想要省略struct就需要用到typedef–类型重定义/重命名 ，例：
方法一

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[8];//性别
	float score;//分数
}s1, s2, s3;//s1,s2,s3是 通过struct Stu类型创建的变量，这里的变量可以写一个，可以写多个，也可以不写
//此时创建的s1,s2,s3是全局变量

typedef struct Stu Stu;

int main()
{
	Stu s6;
	//这里的s6是局部变量
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如果想要省略struct就需要用到typedef–类型重定义/重命名 ，例：
方法二

typedef struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[8];//性别
	float score;//分数
}Stu;//这里的Stu就不是变量列表了，Stu是这个类型的重命名

int main()
{
	Stu s6; 
	//这里的s6是局部变量
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.3结构成员的类型

  结构体的成员可以是标量、数组、指针，甚至其它结构体。
标量：就是普通直观的变量，例如：int age，float score就是标量

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

2.1变量的定义和初始化

struct Point //类型声明
{
	int x;
	int y;
}p1 = { 10,15 };//给变量p1初始化10行，15列,初始化要用大括号{}

struct S 
{
	char c;
	struct Point sp;
	double d;
	char arr[20];
};

//结构体中的也可以有指针，指针在初试化的时候给他放地址就行，如果不知道是社么地址就放入空指针就行NULL，例：
struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10,{4,5},NULL };

int main()
{
	struct Point p = { 100 ,200 };
	struct S ss = { 'w',{100,20},5.5,"hello" }; //对复杂结构体进行嵌套初始化
	struct Node n2 = { 20,{5,6},NULL };//结构体嵌套初始化
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.结构体成员访问

3.1使用结构成员操作符

3.1.1’.'点操作符的使用

//->  结构体指针

struct Point //类型声明
{
	int x;
	int y;
}p1 = { 10,15 };//给变量p1初始化10行，15列
struct S 
{
	char c;
	struct Point sp;
	double d;
	char arr[20];
};

int main()
{ 
	struct S ss = { 'w',{100,20},5.5,"hello" }; //对复杂结构体进行嵌套初始化
	//打印结构体成员
	printf("%c\n", ss.c);//ss.c就是ss的成员c,这里就使用了‘.’点操作符
	printf("%d %d\n", ss.sp.x, ss.sp.y);//打印横纵坐标x,y
	printf("%lf\n", ss.d);
	printf("%s\n", ss.arr);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.1.2’->'箭头操作符的使用

->:  结构体指针->结构体成员
struct Point //类型声明
{
	int x;
	int y;
}p1 = { 10,15 };//给变量p1初始化10行，15列
struct S
{
	char c;
	struct Point sp;
	double d;
	char arr[20];
};

void print1(struct S s)
{
	printf("%c\n", s.c);//ss.c就是ss的成员c,这里就使用了‘.’点操作符
	printf("%d %d\n", s.sp.x, s.sp.y);//打印横纵坐标x,y
	printf("%lf\n", s.d);
	printf("%s\n", s.arr);
}

void print2(struct S* ps) //ps是结构体指针，指向ss
{
	printf("%c\n", ps->c); //ps->,就表示ps指向结构体成员c
	printf("%d %d\n", ps->sp.x, ps->sp.y);//ps指向对象sp，sp是结构体成员变量，他里面有两个成员一个是x,一个是y
	printf("%lf\n", ps->d) ; 
	printf("%s\n", ps->arr);
}
int main()   
{
	struct S ss = { 'w',{100,20},5.5,"hello" }; //对复杂结构体进行嵌套初始化
	//打印结构体成员

	//print1(ss);//调用print1()函数打印 struct S类型的变量
	print2(&ss); //将ss的地址传给函数print2();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

【注意】print2(&ss)这种传地址的方式更加节省空间，如果直接使用print1(ss)串实参给形参，此时形参就是实参的临时拷贝，假如一个函数的结构体占用100个字节，临时拷贝给形参后整体又增加100个字节，同时还花费了许多时间。然而转地址这种方式所占用的空间可能就只有几个字节。

//函数传参时，参数是需要压栈的。
//如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
结论：结构体传参的时候，要传结构体的地址

4.结构体传参

在以上3.结构体成员访问中也涉及到了传参。

4.1修改结构体成员变量的参数

int main()   
{
	struct S ss = { 'w',{100,20},5.5,"hello" }; //对复杂结构体进行嵌套初始化
	//打印结构体成员
	ss.c = 'b';
	ss.sp.x = 1000;
	ss.sp.y = 2000;
	ss.d = 3.14;
	strcpy(ss.arr, "world");//strcpy字符串拷贝，由于strcpy是库函数所以需要应用#include <string.h>头文件
	//print1(ss);//调用print1()函数打印 struct S类型的变量
	print2(&ss); //将ss的地址传给函数print2();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

以上就是初识结构体的介绍，创作不易，期待三连，谢谢