[C语言日寄]以指针进阶：空类型指针与qsort函数

【作者主页】siy2333
【专栏介绍】⌈c语言日寄⌋：这是一个专注于C语言刷题的专栏，精选题目，搭配详细题解、拓展算法。从基础语法到复杂算法，题目涉及的知识点全面覆盖，助力你系统提升。无论你是初学者，还是进阶开发者，这里都能满足你的需求！
【食用方法】1.根据题目自行尝试 2.查看基础思路完善题解 3.学习拓展算法
【Gitee链接】资源保存在我的Gitee仓库：https://gitee.com/siy2333/study

前言

在C语言的学习中，指针始终是一个核心且难以绕开的话题。它既强大又容易出错，但一旦掌握，就能极大地提升代码的灵活性和效率。今天，我们将通过一个具体的题目，深入探讨空类型指针（void*）和C标准库中的qsort函数，帮助大家更好地理解和应用指针的高级特性。

一、题目引入

在C语言中，qsort函数是标准库中提供的一个通用排序函数，它可以对任意类型的数组进行排序。它的声明如下：

#include <stdlib.h>
void qsort(void* base, size_t nitems, size_t size, int (*compar)(const void*, const void*));

我们先来看一个简单的题目：
假设有一个整型数组int arr[] = {5, 3, 8, 1, 2, 9};，请使用qsort函数对其进行升序排序，并输出排序后的结果。
这个问题看似简单，但涉及到指针的高级用法——空类型指针void*，以及如何正确地使用qsort函数。接下来，我们将逐步分析这个问题，并通过它深入学习相关的知识点。

二、知识点分析

（一）空类型指针: void*

void*是一种特殊的指针类型，它表示“没有类型”的指针。void*指针可以指向任意类型的数据，但在使用时必须进行强制类型转换，因为void*本身不能直接进行解引用操作。

1. 声明与赋值

   • void*指针的声明方式如下：

     void* ptr;
     

   • 它可以指向任意类型的变量，例如：

     int a = 10;
     ptr = &a; // ptr指向一个int类型的变量
     

2. 强制类型转换

   • 在使用void*指针时，通常需要将其转换为具体的类型指针，以便进行解引用或其他操作。例如：

     int* int_ptr = (int*)ptr; // 将void*转换为int*
     printf("%d\n", *int_ptr); // 输出10
     

3. void*在qsort中的作用

   • 在qsort函数中，void* base参数表示待排序数组的首地址。由于qsort需要处理任意类型的数组，因此使用void*作为参数类型，以确保函数的通用性。在比较函数中，const void*类型的参数也需要进行相应的类型转换。

（二）qsort函数的使用

qsort函数是一个通用排序函数，它的参数含义如下：

1. void* base

   • 指向待排序数组的首地址。由于qsort需要处理任意类型的数组，因此使用void*作为参数类型。

2. size_t nitems

   • 表示数组中元素的数量。

3. size_t size

   • 表示数组中每个元素的大小（以字节为单位）。例如，对于整型数组int arr[]，每个元素的大小为sizeof(int)。

4. int (*compar)(const void*, const void*)

   • 比较函数的指针。比较函数的原型为：

     int compar(const void* a, const void* b);
     

   • 比较函数的返回值决定了排序的顺序：
     • 如果返回值小于0，则表示a小于b；
     • 如果返回值等于0，则表示a等于b；
     • 如果返回值大于0，则表示a大于b。

（三）题目分析与实现

回到我们最初的问题：对整型数组int arr[] = {5, 3, 8, 1, 2, 9};进行升序排序。

1. 定义比较函数

   • 对于整型数组的升序排序，比较函数可以这样实现：

     int compare(const void* a, const void* b) {
         int int_a = *(const int*)a; // 将void*转换为int*，并解引用
         int int_b = *(const int*)b;
         return int_a - int_b; // 升序排序
     }
     

2. 调用qsort函数

   • 使用qsort函数对数组进行排序：

     #include <stdio.h>
     #include <stdlib.h>
     
     int compare(const void* a, const void* b) {
         return (*(int*)a - *(int*)b);
     }
     
     int main() {
         int arr[] = {5, 3, 8, 1, 2, 9};
         int n = sizeof(arr) / sizeof(arr[0]); // 数组元素数量
     
         qsort(arr, n, sizeof(int), compare); // 调用qsort
     
         for (int i = 0; i < n; i++) {
             printf("%d ", arr[i]); // 输出排序后的结果
         }
         return 0;
     }
     

3. 输出结果

   • 程序的输出结果为：

     1 2 3 5 8 9
     

三、注意事项

（一）void*的类型转换

1. 必须进行类型转换

   • void*指针不能直接解引用，必须先转换为具体的类型指针。例如：

     void* ptr = &a;
     int value = *(int*)ptr; // 必须转换为int*后才能解引用
     

2. 转换的安全性

   • 在进行类型转换时，必须确保转换的类型与实际数据类型一致，否则可能导致未定义行为。例如，将指向int的void*错误地转换为char*并解引用，可能会导致错误的结果或程序崩溃。

（二）qsort的比较函数

1. 参数类型

   • 比较函数的参数类型为const void*，表示指向数组元素的指针。在比较函数中，需要将void*转换为具体的类型指针。

2. 返回值

   • 比较函数的返回值决定了排序的顺序。返回值的正负关系必须明确，否则可能导致排序结果不符合预期。

3. 数组元素大小

   • 在调用qsort时，必须正确指定数组中每个元素的大小（size参数）。对于不同类型的数组（如int、float、struct等），size参数的值是不同的。

（三）调试与测试

1. 测试不同类型的数组

   • 在使用qsort时，建议对不同类型的数组（如整型数组、浮点型数组、结构体数组等）进行测试，以确保比较函数的正确性。

2. 边界情况测试

   • 测试数组为空或只有一个元素的情况，以确保程序的鲁棒性。

四、拓展应用

（一）对浮点型数组排序

假设有一个浮点型数组float arr[] = {3.5, 2.1, 4.8, 1.2, 0.5};，请使用qsort函数对其进行升序排序。

1. 定义比较函数

   • 对于浮点型数组的升序排序，比较函数可以这样实现：

     int compare_float(const void* a, const void* b) {
         float float_a = *(const float*)a;
         float float_b = *(const float*)b;
         return (float_a > float_b) - (float_a < float_b); // 升序排序
     }
     

2. 调用qsort函数

   • 使用qsort函数对数组进行排序：

     #include <stdio.h>
     #include <stdlib.h>
     
     int compare_float(const void* a, const void* b) {
         return (*(float*)a > *(float*)b) - (*(float*)a < *(float*)b);
     }
     
     int main() {
         float arr[] = {3.5, 2.1, 4.8, 1.2, 0.5};
         int n = sizeof(arr) / sizeof(arr[0]);
     
         qsort(arr, n, sizeof(float), compare_float);
     
         for (int i = 0; i < n; i++) {
             printf("%.2f ", arr[i]);
         }
         return 0;
     }
     

3. 输出结果

   • 程序的输出结果为：

     0.50 1.20 2.10 3.50 4.80
     

（二）对结构体数组排序

假设有一个结构体数组，存储了学生的信息，包括学号、姓名和成绩。请使用qsort函数按成绩升序排序。

1. 定义结构体

   • 定义一个学生信息结构体：

     struct Student {
         int id;
         char name[20];
         float score;
     };
     

2. 定义比较函数

   • 按成绩升序排序的比较函数：

     int compare_score(const void* a, const void* b) {
         struct Student* student_a = (struct Student*)a;
         struct Student* student_b = (struct Student*)b;
         return (student_a->score > student_b->score) - (student_a->score < student_b->score);
     }
     

3. 调用qsort函数

   • 使用qsort函数对结构体数组进行排序：

     #include <stdio.h>
     #include <stdlib.h>
     
     struct Student {
         int id;
         char name[20];
         float score;
     };
     
     int compare_score(const void* a, const void* b) {
         struct Student* student_a = (struct Student*)a;
         struct Student* student_b = (struct Student*)b;
         return (student_a->score > student_b->score) - (student_a->score < student_b->score);
     }
     
     int main() {
         struct Student students[] = {
             {1, "Alice", 85.5},
             {2, "Bob", 92.3},
             {3, "Charlie", 78.9}
         };
         int n = sizeof(students) / sizeof(students[0]);
     
         qsort(students, n, sizeof(struct Student), compare_score);
     
         for (int i = 0; i < n; i++) {
             printf("ID: %d, Name: %s, Score: %.2f\n", students[i].id, students[i].name, students[i].score);
         }
         return 0;
     }
     

4. 输出结果

   • 程序的输出结果为：

     ID: 3, Name: Charlie, Score: 78.90
     ID: 1, Name: Alice, Score: 85.50
     ID: 2, Name: Bob, Score: 92.30
     

（三）自定义排序规则

在实际应用中，我们还可以根据需求自定义排序规则。例如，对字符串数组按字典序排序，或者对结构体数组按多个字段排序。

1. 对字符串数组排序

   • 假设有一个字符串数组char* arr[] = {"apple", "banana", "cherry", "date"};，按字典序排序：

     #include <stdio.h>
     #include <stdlib.h>
     #include <string.h>
     
     int compare_string(const void* a, const void* b) {
         return strcmp(*(const char**)a, *(const char**)b);
     }
     
     int main() {
         char* arr[] = {"apple", "banana", "cherry", "date"};
         int n = sizeof(arr) / sizeof(arr[0]);
     
         qsort(arr, n, sizeof(char*), compare_string);
     
         for (int i = 0; i < n; i++) {
             printf("%s\n", arr[i]);
         }
         return 0;
     }
     

2. 对结构体数组按多个字段排序

   • 假设需要先按成绩排序，如果成绩相同，则按学号排序：

     int compare_student(const void* a, const void* b) {
         struct Student* student_a = (struct Student*)a;
         struct Student* student_b = (struct Student*)b;
     
         if (student_a->score != student_b->score) {
             return (student_a->score > student_b->score) - (student_a->score < student_b->score);
         } else {
             return student_a->id - student_b->id;
         }
     }
     

五、总结

通过今天的讲解，我们深入探讨了空类型指针void*和qsort函数的使用。void*作为一种通用指针类型，为我们提供了极大的灵活性，但也需要注意类型转换的安全性。qsort函数则是一个强大的工具，能够对任意类型的数组进行排序，只要我们正确地定义比较函数。

希望今天的讲解对你有所帮助，如果你还有其他疑问，欢迎在评论区留言讨论。关注窝，每三天至少更新一篇优质c语言题目详解~

[专栏链接QwQ] :⌈c语言日寄⌋CSDN
[关注博主ava]：siy2333
感谢观看~ 我们下次再见!!