探索指针（4）-C语言

目录

1.回调函数

一.回调函数的基本概念

二.示例

三.详细说明

2.qsort使用举例

一.qsort 函数原型 

二.参数解释

三.比较函数

3.qsort函数的模拟实现

一.代码示例：

二.分段讲解代码 

---

1.回调函数

一.回调函数的基本概念

回调函数本质上是一种通过函数指针实现的机制。你可以定义一个函数指针，然后将其作为参数传递给另一个函数，当需要时调用该指针所指向的函数。

二.示例

以下是一个简单的示例，展示如何在C语言中使用回调函数。

1. 定义一个函数类型（函数指针）和一个函数来调用回调函数。
2. 定义实际的回调函数。
3. 将回调函数传递给调用函数并执行。

#include <stdio.h>

// 定义一个函数类型，表示一个接收两个int参数并返回int的函数
typedef int (*callback_t)(int, int);

// 一个简单的加法函数，可以作为回调函数
int add(int a, int b) {
    return a + b;
}

// 一个简单的减法函数，可以作为回调函数
int subtract(int a, int b) {
    return a - b;
}

// 一个执行回调函数的函数
void execute_callback(callback_t callback, int x, int y) {
    int result = callback(x, y);
    printf("Result: %d\n", result);
}

int main() {
    // 使用add函数作为回调函数
    execute_callback(add, 5, 3); // 输出: Result: 8

    // 使用subtract函数作为回调函数
    execute_callback(subtract, 5, 3); // 输出: Result: 2

    return 0;
}

三.详细说明

1. 函数指针类型定义

 typedef int (*callback_t)(int, int)

 这里我们定义了一个新的类型 callback_t，它表示一个接收两个 int 参数并返回 int 的函数指针。

        2.回调函数的定义：    

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

我们定义了两个简单的函数 add 和 subtract，它们都符合 callback_t 类型。 

        3.调用回调函数的函数： 

void execute_callback(callback_t callback, int x, int y) {
    int result = callback(x, y);
    printf("Result: %d\n", result);
}

execute_callback 函数接收一个 callback_t 类型的回调函数和两个 int 参数，然后调用回调函数并打印结果。

        4.主函数中的调用:

int main() {
    execute_callback(add, 5, 3);
    execute_callback(subtract, 5, 3);
    return 0;
}

图文解释; 

2.qsort使用举例

qsort 是 C 标准库中用于对数组进行快速排序的函数。qsort 函数定义在 stdlib.h 头文件中，它可以对任意类型的数组进行排序，只需提供一个比较函数来确定元素的排序顺序。

一.qsort 函数原型 

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

二.参数解释

• base：指向要排序的数组的起始地址。
• nmemb：数组中的元素个数。
• size：每个元素的大小（以字节为单位）。
• compar：指向比较函数的指针，用于比较两个元素。

三.比较函数

比较函数接收两个 const void* 类型的参数，返回一个整数值：

• 返回负值：如果第一个参数小于第二个参数。
• 返回零：如果两个参数相等。
• 返回正值：如果第一个参数大于第二个参数。 

以下是一个使用 qsort 对整数数组进行排序的示例：

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

// 比较函数，用于比较两个整数
int compare_ints(const void *a, const void *b) {
    int int_a = *(int *)a;
    int int_b = *(int *)b;
    
    if (int_a < int_b) return -1;
    else if (int_a == int_b) return 0;
    else return 1;
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    size_t arr_size = sizeof(arr) / sizeof(arr[0]);

    // 使用qsort对数组进行排序
    qsort(arr, arr_size, sizeof(int), compare_ints);

    // 输出排序后的数组
    for (size_t i = 0; i < arr_size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

 以下是一个对结构体数组进行排序的示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义一个结构体
typedef struct {
    char name[20];
    int age;
} Person;

// 比较函数，用于比较两个Person结构体的年龄
int compare_persons(const void *a, const void *b) {
    Person *person_a = (Person *)a;
    Person *person_b = (Person *)b;
    
    return (person_a->age - person_b->age);
}

int main() {
    Person people[] = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}};
    size_t people_size = sizeof(people) / sizeof(people[0]);

    // 使用qsort对结构体数组进行排序
    qsort(people, people_size, sizeof(Person), compare_persons);

    // 输出排序后的结构体数组
    for (size_t i = 0; i < people_size; i++) {
        printf("%s: %d\n", people[i].name, people[i].age);
    }

    return 0;
}

 在这个示例中，我们定义了一个 Person 结构体，并编写了一个比较函数 compare_persons，用于比较 Person 结构体的年龄。然后使用 qsort 对结构体数组按年龄进行排序。

3.qsort函数的模拟实现

一.代码示例：

#include <stdio.h>
#include <stdlib.h>//qsort

int compare(const void* a, const void* b)
{
	if (*(int*)a < *(int*)b)
		return -1;
	if (*(int*)a == *(int*)b)
		return 0;
	if (*(int*)a > *(int*)b)
		return 1;
}

void swap(char* a1, char* a2,int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = 0;
		tmp = *a1;
		*a1 = *a2;
		*a2 = tmp;

		a1++;
		a2++;
	}
}
//qsort的模拟实现（使用冒泡排序）
void my_qsort(void* base, size_t num,
	size_t size, int (*compar)(const void*, const void*))
{
	int i = 0;
	for (i = 0; i < num-1; i++)
	{
		int j = 0;
		for (j = 0; j < num - i - 1; j++)
		{
			if (compare((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
			}
		}
	}
}

int main()
{
	int arr[] = { 23,41,4,6,56,3,525,7,8,4,23,6 };

	int num = sizeof(arr) / sizeof(arr[0]);
	my_qsort(arr, num, sizeof(arr[0]), compare);

	int i = 0;
	for (i = 0; i < num; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

二.分段讲解代码 

比较函数：

int compare(const void* a, const void* b)
{
    if (*(int*)a < *(int*)b)
        return -1;
    if (*(int*)a == *(int*)b)
        return 0;
    if (*(int*)a > *(int*)b)
        return 1;
}

• 这个函数用于比较两个整数。
• 它接收两个 const void* 类型的参数，通过类型转换将它们转换为 int*，然后进行比较。
• 根据比较结果返回负值、零或正值，分别表示第一个参数小于、等于或大于第二个参数。

交换函数 :

void swap(char* a1, char* a2, int size)
{
    int i = 0;
    for (i = 0; i < size; i++)
    {
        char tmp = 0;
        tmp = *a1;
        *a1 = *a2;
        *a2 = tmp;

        a1++;
        a2++;
    }
}

• 这个函数用于交换两个元素的内容。
• 它接收两个 char* 类型的指针和一个 size 参数，表示元素的大小。
• 通过循环逐字节地交换两个元素的内容。

 my_qsort 函数:

void my_qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
{
    int i = 0;
    for (i = 0; i < num-1; i++)
    {
        int j = 0;
        for (j = 0; j < num - i - 1; j++)
        {
            if (compare((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
            {
                swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
            }
        }
    }
}

• 这个函数是 qsort 函数的模拟实现，使用冒泡排序算法对数组进行排序。
• 参数说明：
  • base：指向要排序的数组的起始地址。
  • num：数组中的元素个数。
  • size：每个元素的大小（以字节为单位）。
  • compar：指向比较函数的指针，用于比较两个元素。
• 外层循环控制排序的轮数，内层循环比较和交换相邻元素。
• 使用 compare 函数比较相邻元素，如果需要交换，调用 swap 函数交换它们。

 

以上就是本次的所有内容，如果对你有所帮助，请不要吝啬你的点赞哦!