详解"/>
C语言之结构体和共用体详解
目录
结构体
结构体的定义和使用
结构体数组的使用
结构体指针的使用
结构体大小的计算
共用体
共用体的定义和使用
typedef用法详解
enum枚举类型
结构体
结构体的定义和使用
C语言的结构体（Struct）是一种自定义的数据类型，它允许我们将不同类型的数据组合在一起，形成一个新的复合数据类型。结构体可以包含多个成员变量，每个成员变量可以有不同的数据类型，这使得结构体能够表示更复杂的数据结构。
以下是关于C语言结构体的详细说明：
1、结构体的定义
结构体的定义使用关键字 struct，后面跟着结构体的名称和一对大括号 {}。在大括号内部，我们可以定义多个成员变量，每个成员变量由类型和名称组成，用分号 ; 分隔。
定义一般形式如下：
struct 结构类型名
{ 数据类型 成员名 1; 数据类型 成员名 2; ...... 数据类型 成员名 n;
};例如，struct Person { char name[20]; int age; float height; }; 定义了一个名为 Person 的结构体，它包含了一个字符数组 name、一个整型变量 age 和一个浮点型变量 height。
2、结构体的声明和初始化
在定义结构体之后，我们可以通过声明结构体变量来使用它。结构体变量的声明方式与普通变量类似，需要指定结构体的类型和变量名。例如，struct Person person1; 声明了一个名为 person1 的结构体变量。我们也可以在声明结构体变量的同时进行初始化，使用一对大括号 {} 将初始化的值括起来，按照成员变量的顺序进行赋值。
结构初始化的一般形式如下：
struct 结构类型名 结构变量 = { 初始化数据 1, ...... 初始化数据 n };例如，struct Person person2 = { "Alice", 25, 1.65 }; 将结构体变量 person2 的成员变量分别初始化为 "Alice"、25 和 1.65。
3、结构体成员的访问
结构体的成员变量可以使用点运算符 . 来访问。
例如，person1.age = 30; 将结构体变量 person1 的 age 成员变量赋值为 30。我们也可以通过结构体指针来访问结构体的成员变量，使用箭头运算符 ->。
例如，struct Person *ptr = &person1; ptr->age = 30; 使用结构体指针 ptr 访问 person1 的 age 成员变量并赋值为 30。
4、结构体作为函数参数和返回值
我们可以将结构体作为函数的参数传递，以便在函数内部操作结构体的成员变量。可以通过值传递或指针传递结构体参数。如果结构体较大，建议使用指针传递，以避免复制整个结构体。同样，函数也可以返回结构体类型的值或指针。
下面是一个简单的示例代码，演示了结构体的使用：
#include <stdio.h>
#include <string.h>
struct Person {char name[20];int age;float height;
};void printPerson(struct Person p) {printf("Name: %s\n", p.name);printf("Age: %d\n", p.age);printf("Height: %.2f\n", p.height);
}int main() {struct Person person1 = { "Alice", 25, 1.65 };printPerson(person1);struct Person person2;strcpy(person2.name, "Bob");person2.age = 30;person2.height = 1.75;printPerson(person2);return 0;
}
在上述示例中，我们定义了一个名为 Person 的结构体，它包含了三个成员变量 name、age 和 height。然后，我们定义了一个名为 printPerson 的函数，它接受一个结构体类型的参数 p，并在函数内部打印结构体的成员变量。
在 main 函数中，我们声明了两个结构体变量 person1 和 person2，并分别对它们的成员变量进行赋值。然后，我们调用 printPerson 函数来打印结构体的内容。
输出结果：
Name: Alice
Age: 25
Height: 1.65
Name: Bob
Age: 30
Height: 1.75
这个示例展示了结构体的基本用法。结构体允许我们将不同类型的数据组合在一起，形成一个新的复合数据类型，从而更好地表示和操作复杂的数据结构。
结构体数组的使用
C语言的结构体数组（Struct Array）是一种将多个结构体对象组合在一起的数据类型。它允许我们定义一个包含多个结构体对象的数组，每个结构体对象都可以包含多个成员变量，这使得结构体数组能够表示更复杂的数据结构。
以下是关于C语言结构体数组的详细说明：
1、结构体数组的定义
结构体数组的定义与普通数组类似，需要指定数组的类型、名称和长度。
例如，struct Person people[3]; 定义了一个名为 people 的结构体数组，它包含了三个元素，每个元素都是一个 Person 结构体对象。
2、结构体数组的初始化
结构体数组的初始化方式与普通数组类似，可以使用一对大括号 {} 将初始化的值括起来，按照数组元素的顺序进行赋值。每个元素的初始化值也可以使用一对大括号 {}，按照结构体成员变量的顺序进行赋值。
例如，struct Person people[3] = { {"Alice", 25, 1.65}, {"Bob", 30, 1.75}, {"Charlie", 35, 1.80} }; 初始化了一个包含三个 Person 结构体对象的结构体数组 people。
3、结构体数组的访问
结构体数组的元素可以使用下标运算符 [] 来访问。例如，people[0].age = 26; 将结构体数组 people 的第一个元素的 age 成员变量赋值为 26。我们也可以通过结构体指针来访问结构体数组的元素，使用箭头运算符 ->。
例如，struct Person *ptr = &people[1]; ptr->age = 31; 使用结构体指针 ptr 访问 people 的第二个元素的 age 成员变量并赋值为 31。
4、结构体数组作为函数参数和返回值
我们可以将结构体数组作为函数的参数传递，以便在函数内部操作结构体数组的元素。可以通过值传递或指针传递结构体数组参数。如果结构体数组较大，建议使用指针传递，以避免复制整个结构体数组。同样，函数也可以返回结构体数组类型的值或指针。
下面是一个简单的示例代码，演示了结构体数组的使用：
#include <stdio.h>struct Person {char name[20];int age;float height;
};void printPeople(struct Person people[], int n) {for (int i = 0; i < n; i++) {printf("Name: %s\n", people[i].name);printf("Age: %d\n", people[i].age);printf("Height: %.2f\n", people[i].height);}
}int main() {struct Person people[3] = { {"Alice", 25, 1.65}, {"Bob", 30, 1.75}, {"Charlie", 35, 1.80} };printPeople(people, 3);return 0;
}
在上述示例中，我们定义了一个名为 Person 的结构体，它包含了三个成员变量 name、age 和 height。然后，我们定义了一个名为 printPeople 的函数，它接受一个结构体数组类型的参数 people 和一个整型变量 n，并在函数内部打印结构体数组的内容。
在 main 函数中，我们声明了一个包含三个 Person 结构体对象的结构体数组 people，并对它们的成员变量进行赋值。然后，我们调用 printPeople 函数来打印结构体数组的内容。
输出结果：
Name: Alice
Age: 25
Height: 1.65
Name: Bob
Age: 30
Height: 1.75
Name: Charlie
Age: 35
Height: 1.80
这个示例展示了结构体数组的基本用法。结构体数组允许我们将多个结构体对象组合在一起，形成一个新的复合数据类型，从而更好地表示和操作复杂的数据结构。
结构体指针的使用
C语言的结构体指针（Struct Pointer）是一种指向结构体对象的指针变量。使用结构体指针可以方便地操作和访问结构体的成员变量，同时也可以减少内存开销和提高程序的效率。以下是关于C语言结构体指针的详细说明：
1、结构体指针的定义
结构体指针的定义与普通指针类似，需要指定指针的类型和名称。
例如，struct Person *ptr; 定义了一个名为 ptr 的结构体指针，它可以指向 Person 结构体类型的对象。
2、结构体指针的赋值
结构体指针可以通过赋值操作指向一个具体的结构体对象。
例如，ptr = &person1; 将结构体指针 ptr 指向 person1 结构体对象的地址。
3、结构体指针的成员访问
通过结构体指针可以方便地访问结构体的成员变量。使用箭头运算符 -> 可以从结构体指针中访问结构体的成员变量。
例如，ptr->age = 25; 将结构体指针 ptr 所指向的结构体对象的 age 成员变量赋值为 25。
4、动态分配结构体指针的内存空间
可以使用 malloc 函数动态分配结构体指针的内存空间。
例如，struct Person *ptr = (struct Person *)malloc(sizeof(struct Person)); 动态分配了一个 Person 结构体对象的内存空间，并将其地址赋值给结构体指针 ptr。
5、结构体指针作为函数参数和返回值
结构体指针可以作为函数的参数传递，以便在函数内部操作结构体对象。通过指针传递结构体参数可以避免复制整个结构体对象，提高程序的效率。同样，函数也可以返回结构体指针类型的值或指针。
下面是一个简单的示例代码，演示了结构体指针的使用：
#include <stdio.h>
#include <stdlib.h>struct Person {char name[20];int age;float height;
};void printPerson(struct Person *ptr) {printf("Name: %s\n", ptr->name);printf("Age: %d\n", ptr->age);printf("Height: %.2f\n", ptr->height);
}int main() {struct Person person1 = {"Alice", 25, 1.65};struct Person *ptr = &person1;printPerson(ptr);struct Person *dynamicPtr = (struct Person *)malloc(sizeof(struct Person));dynamicPtr->age = 30;printf("Dynamic Person's Age: %d\n", dynamicPtr->age);free(dynamicPtr);return 0;
}
在上述示例中，我们定义了一个名为 Person 的结构体，它包含了三个成员变量 name、age 和 height。然后，我们定义了一个名为 printPerson 的函数，它接受一个结构体指针类型的参数 ptr，并在函数内部打印结构体指针所指向的结构体对象的内容。
在 main 函数中，我们声明了一个 Person 结构体对象 person1，并使用 & 运算符获取其地址，并将其赋值给结构体指针 ptr。然后，我们调用 printPerson 函数来打印结构体指针所指向的结构体对象的内容。
接下来，我们使用 malloc 函数动态分配了一个 Person 结构体对象的内存空间，并将其地址赋值给结构体指针 dynamicPtr。我们可以通过结构体指针 dynamicPtr 访问和修改动态分配的结构体对象的成员变量。最后，我们使用 free 函数释放了动态分配的内存空间，以防止内存泄漏。
输出结果：
Name: Alice
Age: 25
Height: 1.65
Dynamic Person's Age: 30
这个示例展示了结构体指针的基本用法。结构体指针可以方便地操作和访问结构体的成员变量，并且可以通过动态分配内存空间来创建和释放结构体对象，从而灵活地管理内存。
结构体大小的计算
在C语言中，结构体的大小是由其成员变量的大小和对齐方式决定的。计算结构体大小的过程如下（详细可见这篇文章）：
1、计算成员变量的大小：
首先，需要计算每个成员变量的大小。对于基本数据类型，可以使用 sizeof 运算符获取其大小。例如，sizeof(int) 返回整型的大小。对于数组类型的成员变量，需要将数组元素的大小乘以数组的长度。
2、对齐成员变量：
结构体的成员变量通常需要按照某种对齐方式排列，以提高内存访问的效率。对齐方式是根据编译器和平台的不同而有所差异的，一般遵循下列规则：
- 成员变量的对齐值为其自身大小和编译器默认对齐值中较小的一个。
- 结构体的对齐值为结构体中最大的成员变量的对齐值。
3、计算结构体的大小：
结构体的大小是成员变量大小之和，再根据对齐方式进行调整。通常，结构体的大小是成员变量大小之和的倍数，且不小于结构体中最大的成员变量的大小。
以下是一个示例来说明结构体大小的计算过程：
#include <stdio.h>struct Example {char c;int i;double d;
};int main() {struct Example ex;printf("Size of char: %zu\n", sizeof(char));printf("Size of int: %zu\n", sizeof(int));printf("Size of double: %zu\n", sizeof(double));printf("Size of struct Example: %zu\n", sizeof(struct Example));return 0;
}
在上述示例中，我们定义了一个名为 Example 的结构体，它包含了一个字符型变量 c、一个整型变量 i 和一个双精度浮点型变量 d。在 main 函数中，我们使用 sizeof 运算符分别打印了各个数据类型的大小以及结构体 Example 的大小。
输出结果：
Size of char: 1
Size of int: 4
Size of double: 8
Size of struct Example: 16
需要注意的是，编译器和平台可能会有不同的对齐方式和默认对齐值，因此不同的环境下计算出的结构体大小可能会有所差异。可以使用 #pragma pack 指令或编译器的特定选项来改变对齐方式和对齐值。
共用体
共用体的定义和使用
共用体（Union）是C语言中的一种特殊数据类型，它允许在相同的内存空间中存储不同类型的数据。共用体的定义和使用如下所示：
1、定义共用体：
共用体的定义与结构体类似，使用 union 关键字，后跟共用体的名称和成员变量列表。共用体的成员变量可以是不同的数据类型，但它们共享同一块内存空间。
union MyUnion {int i;float f;char c;
};
在上述示例中，我们定义了一个名为 MyUnion 的共用体，它包含了一个整型变量 i、一个浮点型变量 f 和一个字符型变量 c。
2、使用共用体：
可以通过共用体的名称和成员变量名来访问共用体的成员变量。由于共用体的成员变量共享同一块内存空间，只能同时存储其中一个成员变量的值。
union MyUnion u;
u.i = 10;
printf("Value of i: %d\n", u.i);
u.f = 3.14;
printf("Value of f: %.2f\n", u.f);
在上述示例中，我们声明了一个 MyUnion 类型的变量 u，并分别给 u.i 和 u.f 赋值。由于它们共享同一块内存空间，改变其中一个成员变量的值会影响到其他成员变量。
3、共用体的大小：
共用体的大小是其最大成员变量的大小。因为共用体的成员变量共享同一块内存空间，所以共用体的大小足够容纳最大的成员变量即可。
使用 sizeof 运算符可以获取共用体的大小。
需要注意的是，共用体虽然灵活，但也存在潜在的问题。由于共用体的成员变量共享同一块内存空间，因此在使用共用体时需要小心，确保对成员变量的访问和修改是合法的。此外，共用体的使用也可能导致类型转换和内存对齐等问题，因此在使用共用体时需要谨慎考虑。
下面是一个完整的示例代码，演示了共用体的定义和使用：
#include <stdio.h>union MyUnion {int i;float f;char c;
};int main() {union MyUnion u;u.i = 10;printf("Value of i: %d\n", u.i);u.f = 3.14;printf("Value of f: %.2f\n", u.f);printf("Size of union MyUnion: %zu\n", sizeof(union MyUnion));return 0;
}
输出结果：
Value of i: 10
Value of f: 3.14
Size of union MyUnion: 4
根据输出结果可知，共用体 MyUnion 的大小是4字节，因为 int 类型的大小为4字节，是共用体中最大的成员变量。
总结一下，共用体是C语言中一种特殊的数据类型，允许在相同的内存空间中存储不同类型的数据。它的定义和使用方式与结构体类似，但共用体的成员变量共享同一块内存空间。需要注意共用体的大小、成员变量的访问和修改，以及潜在的类型转换和内存对齐问题。
typedef用法详解
在C语言中，typedef 是一个关键字，用于为已有的数据类型创建一个新的名称。它可以简化代码，提高可读性，并使代码更具可维护性。typedef 的用法如下：
1、为基本数据类型创建别名：
typedef 可以为基本数据类型（如 int、float、char 等）创建别名，使其在代码中使用起来更加直观。
typedef int myInt;
typedef float myFloat;
typedef char myChar;
在上述示例中，我们为 int 类型创建了别名 myInt，为 float 类型创建了别名 myFloat，为 char 类型创建了别名 myChar。
2、为结构体创建别名：
typedef 还可以为结构体创建别名，使结构体类型更易于使用。
typedef struct {int x;int y;
} Point;
在上述示例中，我们为一个匿名的结构体创建了别名 Point，该结构体包含了两个整型成员变量 x 和 y。
3、为指针类型创建别名：
typedef 还可以为指针类型创建别名，使指针类型的声明更加简洁明了。
typedef int* IntPtr;
typedef float* FloatPtr;
在上述示例中，我们为 int* 类型创建了别名 IntPtr，为 float* 类型创建了别名 FloatPtr。
4、为函数指针创建别名：
typedef 还可以为函数指针类型创建别名，使函数指针类型的声明更加简洁明了。
typedef int (*MathFunc)(int, int);
在上述示例中，我们为接受两个 int 类型参数并返回 int 类型结果的函数指针创建了别名 MathFunc。
使用 typedef 创建别名后，我们可以直接使用别名来声明变量，而无需再写出完整的数据类型。
下面是一个完整的示例代码，演示了 typedef 的用法：
#include <stdio.h>// 为基本数据类型创建别名
typedef int myInt;
typedef float myFloat;
typedef char myChar;// 为结构体创建别名
typedef struct {int x;int y;
} Point;// 为指针类型创建别名
typedef int* IntPtr;
typedef float* FloatPtr;// 为函数指针创建别名
typedef int (*MathFunc)(int, int);// 定义一个函数，接受两个 int 类型参数并返回它们的和
int sum(int a, int b) {return a + b;
}int main() {// 使用别名声明变量myInt num = 10;myFloat pi = 3.14;myChar letter = 'A';Point p;p.x = 5;p.y = 3;IntPtr pInt;FloatPtr pFloat;MathFunc add = sum;int result = add(2, 3);// 输出变量的值printf("num = %d\n", num);printf("pi = %.2f\n", pi);printf("letter = %c\n", letter);printf("p.x = %d, p.y = %d\n", p.x, p.y);printf("result = %d\n", result);return 0;
}
输出结果：
num = 10
pi = 3.14
letter = A
p.x = 5, p.y = 3
result = 5
根据输出结果可知，我们使用 typedef 创建的别名来声明变量，使代码更加简洁易读。
enum枚举类型
在 C 语言中，enum 是一种枚举类型，用于定义一个新的数据类型，该类型的取值只能是预先定义好的一些枚举常量。枚举类型可以使代码更加易读易懂，同时也可以提高代码的可维护性。
枚举类型的定义格式如下：
enum 枚举名 {枚举常量1,枚举常量2,...
};
其中，枚举名是新定义的枚举类型的名称，枚举常量是该枚举类型中定义的可取值的常量。枚举常量默认从 0 开始递增，也可以手动指定初始值。例如：
enum Color {RED, // 枚举常量 RED 的值为 0GREEN, // 枚举常量 GREEN 的值为 1BLUE // 枚举常量 BLUE 的值为 2
};enum Status {OK = 200, // 枚举常量 OK 的值为 200BAD_REQUEST, // 枚举常量 BAD_REQUEST 的值为 201NOT_FOUND // 枚举常量 NOT_FOUND 的值为 202
};
在上述示例中，我们分别定义了两个枚举类型 Color 和 Status，并为它们定义了一些枚举常量。在第一个枚举类型中，我们未手动指定枚举常量的值，因此它们默认从 0 开始递增。在第二个枚举类型中，我们手动指定了枚举常量的初始值。
定义完枚举类型后，我们可以使用该枚举类型来声明变量。例如：
enum Color c = RED;
enum Status s = OK;
在上述示例中，我们使用 enum 定义的枚举类型 Color 和 Status 来声明了变量 c 和 s，并分别将它们的值初始化为 RED 和 OK。
枚举类型还可以与 switch 语句一起使用，使代码更加清晰易懂。例如：
enum Color c = GREEN;switch (c) {case RED:printf("The color is red.\n");break;case GREEN:printf("The color is green.\n");break;case BLUE:printf("The color is blue.\n");break;default:printf("Unknown color.\n");break;
}
在上述示例中，我们使用 enum 定义的枚举类型 Color 来声明了变量 c，并将其值初始化为 GREEN。然后，我们使用 switch 语句根据变量 c 的值输出不同的结果。
总结一下，enum 是 C 语言中的一种枚举类型，用于定义一个新的数据类型，该类型的取值只能是预先定义好的一些枚举常量。枚举类型可以使代码更加易读易懂，同时也可以提高代码的可维护性。我们可以使用 enum 定义枚举类型，并为枚举常量手动指定初始值。定义完枚举类型后，我们可以使用该枚举类型来声明变量，并与 switch 语句一起使用。
下面是一个使用 enum 的代码示例，该示例定义了一个枚举类型 Weekday，并在 main 函数中使用该枚举类型输出当前是星期几：
#include <stdio.h>// 定义枚举类型 Weekday
enum Weekday {MON,TUE,WED,THU,FRI,SAT,SUN
};int main() {// 获取当前是星期几int weekday = 1; // 假设今天是星期二// 使用 switch 语句根据 weekday 输出不同的结果switch (weekday) {case MON:printf("Today is Monday.\n");break;case TUE:printf("Today is Tuesday.\n");break;case WED:printf("Today is Wednesday.\n");break;case THU:printf("Today is Thursday.\n");break;case FRI:printf("Today is Friday.\n");break;case SAT:printf("Today is Saturday.\n");break;case SUN:printf("Today is Sunday.\n");break;default:printf("Invalid weekday.\n");break;}return 0;
}
在上述示例中，我们首先定义了一个枚举类型 Weekday，并为其定义了七个枚举常量，分别代表星期一到星期日。然后，在 main 函数中，我们假设今天是星期二，将其赋值给变量 weekday。最后，我们使用 switch 语句根据变量 weekday 输出不同的结果。由于 weekday 的值为 1，因此输出的结果是 "Today is Tuesday."。
更多推荐
C语言之结构体和共用体详解
发布评论