C语言：定义和利用结构体变量

介绍

在C语言中，结构体（struct）是一种用户定义的数据类型，它允许我们将差别类型的数据组合在一起。结构体对于处理干系联的数据非常有效，好比将一个人的姓名、年龄和地址组合在一起。
根本用法

1.定义结构体

定义结构体的语法如下：

1. struct 结构体名 {
2.     数据类型 成员名1;
3.     数据类型 成员名2;
4.     ...
5.     数据类型 成员名N;
6. };

复制代码

比方，我们可以定义一个表示人的结构体：

1. #include <stdio.h>
3. // 定义结构体
4. struct Person {
5.     char name[50];
6.     int age;
7.     char address[100];
8. };

复制代码

2. 声明结构体变量

在定义告终构体之后，我们可以声明结构体变量：

1. // 声明结构体变量
2. struct Person person1;

复制代码

我们也可以在定义结构体时同时声明结构体变量：

1. struct Person {
2.     char name[50];
3.     int age;
4.     char address[100];
5. } person1, person2;

复制代码

3. 初始化和访问结构体成员

我们可以利用点运算符（.）来访问和赋值结构体的成员：

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6.     char address[100];
7. };
9. int main() {
10.     // 声明并初始化结构体变量
11.     struct Person person1 = {"Alice", 30, "123 Main St"};
12.    
13.     // 访问结构体成员
14.     printf("Name: %s\n", person1.name);
15.     printf("Age: %d\n", person1.age);
16.     printf("Address: %s\n", person1.address);
17.    
18.     // 修改结构体成员
19.     person1.age = 31;
20.     printf("Updated Age: %d\n", person1.age);
21.    
22.     return 0;
23. }

复制代码

输出结果：

4. 利用指针访问结构体成员

我们还可以通过指针访问结构体成员，利用箭头运算符（->）：

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6.     char address[100];
7. };
9. int main() {
10.     struct Person person1 = {"Bob", 25, "456 Elm St"};
11.     struct Person *ptr_person = &person1;
12.    
13.     // 使用指针访问结构体成员
14.     printf("Name: %s\n", ptr_person->name);
15.     printf("Age: %d\n", ptr_person->age);
16.     printf("Address: %s\n", ptr_person->address);
17.    
18.     // 通过指针修改结构体成员
19.     ptr_person->age = 26;
20.     printf("Updated Age: %d\n", ptr_person->age);
21.    
22.     return 0;
23. }

复制代码

输出结果：

5. 利用结构体数组

偶然候我们需要处理多个相同类型的结构体变量，这时可以利用结构体数组：

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6.     char address[100];
7. };
9. int main() {
10.     // 定义结构体数组
11.     struct Person people[2] = {
12.         {"Charlie", 22, "789 Maple St"},
13.         {"Dana", 28, "101 Oak St"}
14.     };
15.    
16.     for (int i = 0; i < 2; i++) {
17.         printf("Person %d:\n", i + 1);
18.         printf("  Name: %s\n", people[i].name);
19.         printf("  Age: %d\n", people[i].age);
20.         printf("  Address: %s\n", people[i].address);
21.     }
22.    
23.     return 0;
24. }

复制代码

输出结果：

高级用法

6. 嵌套结构体

结构体可以包含其他结构体作为它的成员，这称为嵌套结构体。嵌套结构体可以帮助我们创建更加复杂的数据结构。

1. #include <stdio.h>
3. struct Address {
4.     char street[100];
5.     char city[50];
6.     char state[20];
7.     int zip;
8. };
10. struct Person {
11.     char name[50];
12.     int age;
13.     struct Address address; // 嵌套结构体
14. };
16. int main() {
17.     struct Person person1 = {"Emily", 35, {"123 Oak St", "Springfield", "IL", 62704}};
18.    
19.     printf("Name: %s\n", person1.name);
20.     printf("Age: %d\n", person1.age);
21.     printf("Address: %s, %s, %s, %d\n",
22.            person1.address.street,
23.            person1.address.city,
24.            person1.address.state,
25.            person1.address.zip);
26.    
27.     return 0;
28. }

复制代码

输出结果：

7. 匿名结构体

在某些情况下，我们可以利用匿名结构体来简化代码。匿名结构体没有名字，可以直接利用。

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6.     struct {
7.         char street[100];
8.         char city[50];
9.         char state[20];
10.         int zip;
11.     } address; // 匿名结构体
12. };
14. int main() {
15.     struct Person person1 = {"Frank", 40, {"456 Pine St", "Riverdale", "NY", 10567}};
16.    
17.     printf("Name: %s\n", person1.name);
18.     printf("Age: %d\n", person1.age);
19.     printf("Address: %s, %s, %s, %d\n",
20.            person1.address.street,
21.            person1.address.city,
22.            person1.address.state,
23.            person1.address.zip);
24.    
25.     return 0;
26. }

复制代码

输出结果：

8. 结构体和动态内存分配

在处理大型数据集或需要动态创建结构体时，可以利用动态内存分配（如malloc和free）。

1. #include <stdio.h>
2. #include <stdlib.h> // 包含 malloc 和 free
3. #include <string.h>
5. struct Person {
6.     char name[50];
7.     int age;
8.     char address[100];
9. };
11. int main() {
12.     // 动态分配内存给结构体
13.     struct Person *person1 = (struct Person *)malloc(sizeof(struct Person));
14.    
15.     if (person1 == NULL) {
16.         printf("Memory allocation failed\n");
17.         return 1;
18.     }
19.    
20.     // 初始化结构体成员
21.     strcpy(person1->name, "George");
22.     person1->age = 45;
23.     strcpy(person1->address, "789 Birch St");
24.    
25.     // 访问结构体成员
26.     printf("Name: %s\n", person1->name);
27.     printf("Age: %d\n", person1->age);
28.     printf("Address: %s\n", person1->address);
29.    
30.     // 释放分配的内存
31.     free(person1);
32.    
33.     return 0;
34. }

复制代码

输出结果：

9. 结构体作为函数参数

结构体可以作为函数的参数传递。传递结构体有两种方式：按值传递和按引用传递。
按值传递

按值传递会复制整个结构体，因此函数内部的修改不会影响原始结构体。

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6. };
8. void printPerson(struct Person p) {
9.     printf("Name: %s\n", p.name);
10.     printf("Age: %d\n", p.age);
11. }
13. int main() {
14.     struct Person person1 = {"Helen", 50};
15.     printPerson(person1);
16.     return 0;
17. }

复制代码

输出结果：

按引用传递

按引用传递通过传递指针，可以修改原始结构体。

1. #include <stdio.h>
3. struct Person {
4.     char name[50];
5.     int age;
6. };
8. void updateAge(struct Person *p, int newAge) {
9.     p->age = newAge;
10. }
12. int main() {
13.     struct Person person1 = {"Ivy", 55};
14.     printf("Before update: Age = %d\n", person1.age);
15.    
16.     updateAge(&person1, 60);
17.     printf("After update: Age = %d\n", person1.age);
18.    
19.     return 0;
20. }

复制代码

输出结果：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。