C语言——结构体——（第21篇）

坚持就是胜利

---

一、结构体类型的声明

1、结构的基础知识

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

数组：一组相同类型元素的集合。
结构体：一组不一定相同类型元素的集合。

生活中描述：
人：名字+性别+年龄+身高+身份证号码+地址…
书：书名+作者+出版社+定价+书号…

复杂对象，不能通过内置类型直接描述和表示。
就有结构体来描述复杂类型。

2、结构的声明

struct tag   //tag 随意更改
{
	member - list;   //成员列表
}variable=list;   //结构体变量列表
1
2
3
4

描述一个学生：

struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
}x1, x2;                 //x1,x2 是 全局变量

struct Stu y1,y2;        //y1,y2 是 全局变量

int main()
{
	struct Stu s1, s2;   //s1,s2 是 局部变量
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

typedef struct Stu    //typedef 重新起个名字
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
}Stu;                 //Stu 就是 struct Stu 的别名

int main()
{
	struct Stu s1;   //局部变量 s1       
	Stu s2;   //局部变量 s2        s1 和 s2 是一样的
	return 0;
}

//在C语言中，没有对结构体类型typedef，struct关键字不能省略
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、结构成员的类型

结构的成员可以是 标量，数组，指针，甚至是 其他结构体

struct S
{
	int a;
	char arr[5];
	int* p;
};

struct B
{
	char ch[10];

	struct S s1;  //结构体中包含结构体

	double d;
};

int main()
{
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

struct S
{
	int a;
	char arr[5];
	int* p;
}s1;                //第一种 定义变量  全局变量

struct S s2;        //第二种 定义变量  全局变量

struct B
{
	char ch[10];
	struct S s;
	double d;
};

int main()
{
	struct S s3;    //第三种 定义变量  局部变量

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

struct S
{
	int a;
	char arr[5];
	int* p;
}s1 = { 100,"abcd",NULL };                                    //第一种 定义变量  全局变量

//注意：在给 arr[5] 赋值的时候，字符串中包含 '\0'，所以最多就只可以 a b c d 这4个字符，再加上 '\0',一共5个字符

int n = 2013;
struct S s2 = { 98,"hehe",&n };                               //第二种 定义变量  全局变量

struct B
{
	char ch[10];
	struct S s;
	double d;
};

int main()
{
	               //如果不想按照顺序，那只要在前面加上 '.'

	struct S s3 = { .arr = "abc",.p = NULL,.a = 1 };         //第三种 定义变量  局部变量

	printf("%d %s %p\n", s3.a, s3.arr, s3.p);    // '.' 结构成员访问操作符
	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

结构体中包含结构体

#include <stdio.h>

struct S
{
	int a;
	char arr[5];
	int* p;
}s1 = { 100,"abcd",NULL };                                   



int n = 2013;
struct S s2 = { 98,"hehe",&n };                               

struct B
{
	char ch[10];
	struct S s;
	double d;
};

int main()
{
	struct S s3 = { .arr = "abc",.p = NULL,.a = 1 };         
	//printf("%d %s %p\n", s3.a, s3.arr, s3.p);   

	struct B sa = { "hello",{20,"aaa",NULL},3.14 };   //结构体中包含结构体

	printf("%s %d %s %p %lf\n", sa.ch, sa.s.a, sa.s.arr, sa.s.p, sa.d);

	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

三、结构体成员访问

1、结构体变量访问成员 结构变量的成员是通过点操作符(.)访问的。点操作符接受两个操作数。

我们可以看到 s 有成员 name 和 age ；那我们如何访问 s 的成员？

struct S s;
strcpy(s.name, "sunchao");   //使用 . 访问 name 成员
s.age = 20;  //使用 . 访问 age 成员
1
2
3

2、结构体指针访问指向变量的成员 有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。
那该如何访问成员。如下：

#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void print(struct Stu* ps)
{
	printf("name = %s   age = %d\n", (*ps).name, (*ps).age);
	printf("name = %s   age = %d\n", ps->name, ps->age);
}

int main()
{
	struct Stu s = { "zhangsan",20 };
	print(&s);   //结构体地址传参
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

问题一：t.name = “张三”，对吗？

#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void set_Stu(struct Stu t)
{
	t.age = 20;        //问题一：
	t.name = "张三";   //错误的，因为 name 是 数组名，是 地址，不可以给 地址 赋值 字符串
}

int main()
{
	struct Stu s = { 0 };   //先不初始化
	set_Stu(s);   //值传递还是址传递？ 这里先尝试 值传递
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

改正一：
用 strcpy 来解决

#include <stdio.h>
#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void set_Stu(struct Stu t)
{
	t.age = 20;
	//t.name = "张三";   //错误的，因为 name 是 数组名，是 地址，不可以给 地址 赋值 字符串

	//正确的方法
	strcpy(t.name, "张三");   //字符串拷贝
} 

int main()
{
	struct Stu s = { 0 };   //先不初始化
	set_Stu(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
23
24

问题二：set_Stu(s);应该“值传递”，还是“址传递”？

#include <stdio.h>
#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void set_Stu(struct Stu t)
{
	t.age = 20;
	//t.name = "张三";   //错误的，因为 name 是 数组名，是 地址，不可以给 地址 赋值 字符串

	//正确的方法
	strcpy(t.name, "张三");   //字符串拷贝
} 

void print_stu(struct Stu t)
{
	printf("%s %d", t.name, t.age);
}

int main()
{
	struct Stu s = { 0 };   //先不初始化
	               
	              //错误
	set_Stu(s);   //值传递还是址传递？ 这里是 值传递。说明 值传递 是错误的。
	print_stu(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
23
24
25
26
27
28
29
30
31
32

改正二：

#include <stdio.h>
#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void set_Stu(struct Stu* t)
{
	(*t).age = 20;       //改变成(*t)
	//t.name = "张三";   //错误的，因为 name 是 数组名，是 地址，不可以给 地址 赋值 字符串

	//正确的方法
	strcpy((*t).name, "张三");   //字符串拷贝  //改变成(*t)
} 

void print_stu(struct Stu t)
{
	printf("%s %d", t.name, t.age);
}

int main()
{
	struct Stu s = { 0 };   //先不初始化
	               
	              //错误
	//set_Stu(s);   //值传递还是址传递？ 这里是 值传递。说明 值传递 是错误的。

	              //正确方法：址传递  并且对应的函数set_Stu(struct Stu* t),改变成对应类型的  struct Stu*
	set_Stu(&s);
	print_stu(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
23
24
25
26
27
28
29
30
31
32
33
34
35

(*t).age
t -> age

#include <stdio.h>
#include <stdio.h>

struct Stu
{
	char name[20];
	int age;
};

void set_Stu(struct Stu* t)
{
	//(*t).age = 20;       //改变成(*t)
	//或者
	t->age = 20;
	//t.name = "张三";   //错误的，因为 name 是 数组名，是 地址，不可以给 地址 赋值 字符串

	//正确的方法
	//strcpy((*t).name, "张三");   //字符串拷贝  //改变成(*t)
	//或者
	strcpy(t->name, "张三");
} 

void print_stu(struct Stu t)
{
	printf("%s %d", t.name, t.age);
}

int main()
{
	struct Stu s = { 0 };   //先不初始化
	               
	              //错误
	//set_Stu(s);   //值传递还是址传递？ 这里是 值传递。说明 值传递 是错误的。

	              //正确方法：址传递  并且对应的函数set_Stu(struct Stu* t),改变成对应类型的  struct Stu*
	set_Stu(&s);
	print_stu(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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

四、结构体传参

int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}

int main()
{
	int a = 3;
	int b = 5;
	int c = 0;
	c = Add(a, b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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
23
24
25
26
27
28

上面的 print1 和 print2 函数哪个好些？

答案是：首选 print2 函数。
原因：函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。

实参传递给形参的时候，形参将是实参的一份临时拷贝。

如果在结构体中，采用值传递，会浪费非常多的空间。上面的例子中，就要开辟（1000*4+4）*2=8008个字节的内存空间。
然而使用址传递，则只要占用4字节或者8字节的地址空间。

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

微软雅黑字体
黑体
3号字
4号字
红色
绿色
蓝色