C语言：深入理解指针(4)

✿༺小陈在拼命༻✿

已于 2024-02-09 00:55:04 修改

阅读量3.4k

点赞数 31

分类专栏： C语言文章标签： c语言开发语言

于 2023-12-16 19:30:44 首次发布

本文链接：https://blog.csdn.net/weixin_51142926/article/details/135025377

版权

C语言专栏收录该内容

20 篇文章 3 订阅

订阅专栏

一、回调函数

函数指针是将函数的地址取出来，再通过函数地址去调用，那为什么不直接用函数名调用呢？？原因是因为函数指针可以用来实现回调函数，而回调函数有自己的应用场景。

回调函数就是⼀个通过函数指针调⽤的函数。 如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。

#include <stdio.h>
int add(int a, int b)
{
 return a + b;
}
int sub(int a, int b)
{
 return a - b;
}
int mul(int a, int b)
{
 return a * b;
}
int div(int a, int b)
{
 return a / b;
}
int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 do
 {
 printf("*************************\n");
 printf(" 1:add 2:sub \n");
 printf(" 3:mul 4:div \n");
 printf(" 0:exit \n");
 printf("*************************\n");
 printf("请选择：");
 scanf("%d", &input);
 switch (input)
 {
 case 1:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = add(x, y);
 printf("ret = %d\n", ret);
 break;
 case 2:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = sub(x, y);
 printf("ret = %d\n", ret);
 break;
 case 3:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = mul(x, y);
 printf("ret = %d\n", ret);
 break;
 case 4:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = div(x, y);
 printf("ret = %d\n", ret);
 break;
 case 0:
 printf("退出程序\n");
 break;
 default:
 printf("选择错误\n");
 break;
 }
 } while (input);
 return 0;
}

以上这段代码中，我们发现case部分的代码总是重复出现，这段代码只有调用函数的逻辑有差异（但是函数的返回类型和形参是一样的），其他输入输出操作都是冗余的，那么这个时候我们可以把调用的函数地址以参数的形式传去，用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实就是使用的回调函数功能。

int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
void calc(int(*pf)(int, int))
{
	int ret = 0;
	int x, y;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}
int main()
{
	int input = 1;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(add);
			break;
		case 2:
			calc(sub);
			break;
		case 3:
			calc(mul);
			break;
		case 4:
			calc(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

回调函数不是由该函数的实现方直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

怎么理解上面这段话呢？我们可以发现回调函数并非直接调用的，而是当需要进行某种运算时（特定需求的发生），根据需求将函数地址传给pf，然后在calc（另外一方）函数中通过pf（间接调用）来调用这个函数。

二、qsort使用举例

前面学习的冒泡排序，只能排序整形数据，那我们如何完成其他数据的排序呢？就得用到qsort

qsort是一个库函数，可以完成任意数据的排序，我们首先通过cplusplus的网站来了解qsort，qsort的头文件是stdlib.h，下面我们能来分析他的形参类型。

1.第一个形参void*base是一个void*类型的指针（因为该数组可能是任意类型，所以只有void*才可以接收任意类型的数据的地址），base指向要排序的数组的第一个元素位置。

2.第二个形参size_t num是一个无符号整型，num指向的是待排序数组中的元素个数。（只要知道元素的个数才能确定比较的次数。）

3.第三个形参size_t size是一个无符号整型，size指向数组中元素的大小（单位是字节，因为qsort完成任何类型的排列，所以对象可能是结构体也可能是整型，需要具体传入去运算）。

4.第四个形参int (*compar)(const void*,const void*));，compar是一个函数指针，返回类型是int类型，两个形参的类型是void*类型。该函数指针指向的函数是用来比较数组中两个元素的方法。这个方法是根据我们的需求（比较整型或者比较结构体数据），去构造一个函数用来比较，构造的函数返回类型和形参类型必须一致。

qsort通过返回值来判断p1和p2的大小，当返回值>0,说明p1大于p2，返回值=0，说明p1=p2，返回值<0,说明p1＜p2。

了解了qsort，下面利用qsort来实现排序。

2.1 使用qsort排序整型数据

int int_cmp(const void* p1, const void* p2)//整型的比较方法
{
	return(*(int*)p1 - *(int*)p2);//void*类型的指针必须强转后才可以进行运算。
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,0,2,1,3 };
	int num = sizeof(arr) / sizeof(arr[0]);//确定数组的个数
	int size = sizeof(int);//确定数组的每个元素占用字节大小
	qsort(arr, num, size, int_cmp);
	for (int i = 0; i < num; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

运行结果：0 1 2 3 4 5 6 7 8 9

注意事项：

1.qsort的使用必须包含头文件stdlib.h

2创建比较方法int_cmp函数时要注意该函数返回的结果必须是>0,=0,<0;

3.int_cmp传入的是void*类型的指针，必须强转成int*类型再解引用才可以进行运算。

4.如果想要完成逆序，将int_cmp的代码return(*(int*)p1 - *(int*)p2)中的p1和p2交换即可。

2.2 使用qsort排序结构体数据

struct Stu//学生
{
	char name[20];//名字
	int age;//年龄
};
//创建用年龄比较的方法
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return((struct Stu*)p1)->age - ((struct Stu*)p2)->age;//也可以写成（*（struct stu*）p1）.age-（*（struct stu*）p2）.age 
	//结构体变量.成员名  或者   结构体指针->成员名
}
//创建用名字比较的方法
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//strcmp函数是专门用来比较字符串大小的
	//字符串的比较方法：从左到右的顺序逐个比较两个字符串的字符，直到遇到第一个不同的字符，然乎根据字符的ascii值来确定两个字符串的大小关系。
}
//创建一个打印数组函数
void prinf(struct Stu s[], int num)
{
	for (int i = 0; i < num; i++)
	{
		printf("第%d个同学的名字是%s,年龄是%d\n", i + 1, s[i].name, s[i].age);
	}
}
int main()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
	int num = sizeof(s) / sizeof(s[0]);//元素个数
	int size = sizeof(struct Stu);//学生类型的大小
	printf("比较前\n");
	prinf(s, num);
	printf("通过年龄比较后\n");
	qsort(s, num, size, cmp_stu_by_age);
	prinf(s, num);
	printf("通过名字比较后\n");
	qsort(s, num, size, cmp_stu_by_name);
	prinf(s, num);
}

运行结果：

比较前
第1个同学的名字是zhangsan,年龄是20
第2个同学的名字是lisi,年龄是30
第3个同学的名字是wangwu,年龄是15
通过年龄比较后
第1个同学的名字是wangwu,年龄是15
第2个同学的名字是zhangsan,年龄是20
第3个同学的名字是lisi,年龄是30
通过名字比较后
第1个同学的名字是lisi,年龄是30
第2个同学的名字是wangwu,年龄是15
第3个同学的名字是zhangsan,年龄是20

注意事项：

1.要访问结构体成员的两个方法：结构体变量.成员名结构体指针->成员名

2.strcmp是专门用来比较字符串的大小的，并且它的返回值也恰好和qsort一样，所以可以直接去调用。字符串的比较方法：从左到右的顺序逐个比较两个字符串的字符，直到遇到第一个不同的字符，然乎根据字符的ascii值来确定两个字符串的大小关系。

3.结构体类型相较于整型类型，不能直接用+-<>等运算符，因为结构体中的成员属性可能有多个，直接比较编译器无法判断根据哪一个成员属性来比较。

三、qsort的模拟实现

qsort展现的是不同数据类型的快速排序，在学习qsort之前，我只知道冒泡排序，而冒泡排序只能排序整型类型，那么我们可以通过会回调函数的方法，来改造冒泡排序，使其成为可以排序任意数据类型的排序方法。

在模拟实现前，我们要比较qsort和冒泡排序，两者的数据类型不一样，所以我们对他的改造需要体现在两个方面。

1.由于数据类型不同，所以比较的方法必须改造。

2.由于不同数据类型占用字节大小不同，在利用指针偏移量操作的时候会有差异，所以交换的方法也必须改造。

3.由于数据类型不同，创建比较方法和交换方法时传入的两个参数必须是void*类型

3.模拟实现qsort，就要保证改造的排序函数bubble的返回类型和形参都要保持一致。

int int_cmp(const void* p1, const void* p2)//比较方法
{
	return(*(int*)p1 - *(int*)p2);
}
void swap(void* p1, void* p2, int size)//交换方法，这里要引入size，让swap函数知道交换的数据是什么类型
{
	for (int i = 0; i < size; i++)
	{
		char temp = *((char*)p1+ i);//void*类型必须要先强制转化成char*类型
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = temp;
		//为什么这里要使用字符类型？，因为我们并不知道传入的是什么数据类型，所以用char*（1个字节）来作为单位元，每次交换一个字节,交换次数恰好和size相同
	}
}
void bubble(void* base, int num, int size, int (*cmp)(const void* p1, const void* p2))
{
	for (int i = 0; i < num - 1;i++)
	{
		for (int j = 0; j < num - i - 1; j++)
		{
			if (int_cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)//不知道是什么数据类型，所以用char*比较好操作，一次只操作一个字节。
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}//使用前必须强转成char*类型
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,0,2,1,3 };
	int num = sizeof(arr) / sizeof(arr[0]);//确定数组的个数
	int size = sizeof(int);//确定数组的每个元素占用字节大小
	bubble(arr, num, size, int_cmp);
	for (int i = 0; i < num; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

运行结果：0 1 2 3 4 5 6 7 8 9

要注意的是，由于交换方法和比较方法的改造，由于不知道比较的是什么数据类型，所以都强转成char*类型进行操作，因为char*类型操作一次是一个字节，方便计算。这样恰好就是一次交换一个字节，执行size次后就完成整个元素的交换。所以必须传入size。

四、NULL、\0、0、'0'、null、NUL的区别

NULL:本质是0，一般用于指针的初始化

\0：\ddd形式的转移字符，本质也是0，在字符串中作为结束标志，ASCII码值为0

0：数字0

'0'：字符0，ASCII码值为48

null/NUL:本质就是\0，作为字符串结束标志

五、C99中的变长数组

在C99标准之前，C语⾔在创建数组的时候，数组大小的指定只能使⽤常量、常量表达式，或者如果我们初始化数据的话，可以省略数组⼤⼩。

int arr1[10];
int arr2[3+5];
int arr3[] = {1,2,3};

这样的语法限制，让我们创建数组就不够灵活，有时候数组⼤了浪费空间，有时候数组⼜⼩了不够⽤的。

C99中给⼀个变⻓数组（variable-length array，简称 VLA）的新特性，允许我们可以使⽤变量指定数组大小。

int n = a+b;
int arr[n];

上⾯⽰例中，数组 arr 就是变⻓数组，因为它的⻓度取决于变量 n 的值，编译器没法事先确定，只有运⾏时才能知道 n 是多少。

变⻓数组的根本特征，就是数组⻓度只有运⾏时才能确定，所以变⻓数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定⼀个估计的⻓度，程序可以在运⾏时为数组分配精确的⻓度。有⼀个⽐较迷惑的点，变⻓数组的意思是数组的⼤⼩是可以使⽤变量来指定的，在程序运⾏的时候，根据变量的⼤⼩来指定数组的元素个数，⽽不是说数组的⼤⼩是可变的。数组的大小⼀旦确定就不能再变化了。

遗憾的是在VS2022上，虽然⽀持⼤部分C99的语法，没有⽀持C99中的变⻓数组，没法测试；

✿༺小陈在拼命༻✿

关注

31
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
6
评论
C语言：深入理解指针(4)

函数指针是将函数的地址取出来，再通过函数地址去调用，那为什么不直接用函数名调用呢？？原因是因为函数指针可以用来实现回调函数，而回调函数有自己的应用场景。如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。以上这段代码中，我们可以把调用的函数地址以参数的形式传去，用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实就是使用的回调函数功能。前面学习的冒泡排序，只能排序整形数据，那我们如何完成其他数据的排序呢？就得用到qsort。
复制链接

扫一扫