【c语言】指针进阶（超详细）
文章目录
- ✈ 指向函数指针数组的指针
-
- 指向函数指针数组的指针的定义
- 指向函数指针数组的数组指针的使用
- ✈回调函数
-
- 回调函数的定义
- 回调函数的使用
- ✈qsort函数
-
- qsort函数的作用
- qsort函数的定义
- qsort函数的头文件
- 1.qsort函数排序整型数组
-
- 比较函数compare
- 主函数
- 2.qsort函数排列结构体数据
-
- 【1】排列结构体中的整型类型
-
- 比较函数
- 主函数以及结构体
- 【2】排列结构体中的字符串类型
-
- 比较函数compare
- 主函数
- 【3】 排列结构体中的浮点型数据
-
- 比较函数compare
- 主函数
- 3.qsort函数排列字符数组类型数据
-
-
- 比较函数compare
- 主函数
-
- ✈使用回调函数，模拟实现qsort（采用冒泡的方式）
-
- 冒泡排序（传送门在此[冒泡排序](https://blog.csdn.net/yyqzjw/article/details/131909947?spm=1001.2014.3001.5501)）
- 模拟实现qsort排整型数组（利用冒泡排序方式）
- 总结
✈ 指向函数指针数组的指针
指向函数指针数组的指针是一个 指针， 指针指向一个 数组 ，数组的元素都是 函数指针 ;
如何定义？
指向函数指针数组的指针的定义
我们可以先定义五个函数
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;
}
分别计算两个变量的加减乘除，然后定义一个函数指针数组用来存放上面4个函数的地址
int(*p[5])(int x, int y) = { 0, add, sub, mul, div };
空出来一个是为了让加减乘除函数与下标对应上
int (*(*pp)[5])(int x,int y) = &p;
这个是指向函数指针数组的数组指针,ta指向的函数指针数组的类型是去掉*pp
int (*()[5])(int x,int y)
这个类型说明数组指针指向的是数组长度是5，每个元素都是地址，每个元素的类型是
int ()(int x,int y)
画图说明一下关系
指向函数指针数组的数组指针的使用
怎么通过这个数组指针pp去使用加减乘除这几个函数呢？？？代码如下
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(*p[5])(int x, int y) = { 0, add, sub, mul, div };
int (*(*pp)[5])(int x, int y) = &p;
int ret = (*(*pp + 1))(3, 4);
printf("%d", ret);
}
在这块解释一下子
(*(*pp + 1))(3, 4)
pp存放的是p[]整个数组的地址，*pp相当于拿到这个数组，也相当于拿到数组的数组名，相当于数组首元素地址，*pp+1为第二个元素地址， 如果在对其解引用得到的是 *（pp+1），这个就是数组第二个元素的内容，也就是说add的地址，因为&add和add打印的结果一样，使用该函数计算3+4；
add(3,4)等价 ((*pp + 1))(3, 4)
✈回调函数
回调函数的定义
回调函数pp()就是一个通过函数指针void(*p)()调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数print(&pp);，当这个指针被用来调用其所指向的函数时pp()，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在if (1)特定的事件或条件发生时由另外的一方调用的，用于对该事件或
条件进行响应。
回调函数的使用
void pp()
{
printf("hahahahaha\n");
}
void print(void(*p)())
{
if (1)
{
p();
}
}
int main()
{ print(&pp);
return 0;
}
根据回调函数的定义，可知pp()函数就是回调函数。
✈qsort函数
qsort函数的作用
我们之前学过的冒泡排序，可以将一个整型数组排好序，如果让我们去排序浮点型，字符型，结构体型，我们应该怎么办呢
qsort函数可以解决这个问题，万物皆可排。那谁谁你怎么插队呢快去排队
qsort函数的定义
在msdn上找到定义，我们可以将定义复制过来
void qsort( void *base,
size_t num,
size_t width,
int (__cdecl *compare )(const void *elem1, const void *elem2 ) );
什么？？？英格力士
下面有请过英语四级的小张同学给翻译翻译哈哈哈哈哈
咳咳，我来了
1.base指针指向的是要排序数组的首地址，因为不清楚要排序的是什么类型的数据，这里用void 可以接收任何类型的指针
2.num是该数组的元素个数
3.width是每个元素的字节大小
4.自定义比较函数compare
第四个位置是一个函数指针来接收一个比较函数的地址，参数用两个指针接收要比较两个元素的地址，因为不知道比较什么类型的数据，就用void的指针接收,比较函数是根据你自己要排列的数据类型自己定义的。
第一个元素大于第二个元素返回大于0的，小于第二个元素返回小于0，等于返回0
qsort函数的头文件
1.qsort函数排序整型数组
比较函数compare
int int_cmp(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}
这里要排整型数据，将void的指针强制类型转化为int,一次可以访问4个字节 ，解引用也可以得到一个整型数据
主函数
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
注意：如果要排成降序只需要将比较函数中的
int int_cmp(const void* p1, const void* p2)
{
return ((int)p2 - (int)p1);
}
2.qsort函数排列结构体数据
【1】排列结构体中的整型类型
比较函数
int int_cmp_age(const void* p1, const void* p2)//按年龄比较
{
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
主函数以及结构体
struct Stu {
char name[20];
int age;
float score;
};
int main()
{
int i = 0;
struct Stu arr[3] = {{"zhangjiawang",18,100},{"zhumiao",50,76},{"liuliu",19,76}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr,sz, sizeof(arr[0]), int_cmp_age);
for (int i = 0; i < 3; i++)
{
printf("%d ", arr[i].age);
}
return 0;
}
运行结果
【2】排列结构体中的字符串类型
比较函数compare
int int_cmp_age(const void* p1, const void* p2)
{
return (strcmp(((struct Stu*)p1)->name), ((struct Stu*)p2)->name);
}
字符串比较用strcmp函数，记得添加头文件string.h
这个是strcmp函数的返回值，和比较函数刚好对应上
主函数
int main()
{
int i = 0;
struct Stu arr[3] = {{"zhangjiawang",18,100},{"zhumiao",50,76},{"liuliu",19,76}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr,sz, sizeof(arr[0]), int_cmp_age);
for (int i = 0; i < 3; i++)
{
printf("%s ", arr[i].name);
}
return 0;
}
运行结果
【3】 排列结构体中的浮点型数据
比较函数compare
int int_cmp_float(const void* p1, const void* p2)
{
return (*(float*)p1 -*(float*)p2);
}
主函数
int main()
{
int i = 0;
struct Stu arr[3] = {{"zhangjiawang",18,100.0},{"zhumiao",50,76.0},{"liuliu",19,77.0}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr,sz, sizeof(arr[0]), int_cmp_float);
for (int i = 0; i < 3; i++)
{
printf("%.1f ", arr[i].score);
}
return 0;
}
运行结果：
3.qsort函数排列字符数组类型数据
比较函数compare
int int_cmp(const void* p1, const void* p2)
{
return (*(char*)p1 - *(char*)p2);
}
主函数
int main()
{
char arr[] = {'b','c','a','f','z','q'};
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(char), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%c ", arr[i]);
}
printf("\n");
return 0;
}
运行结果
✈使用回调函数，模拟实现qsort（采用冒泡的方式）
冒泡排序（传送门在此冒泡排序）
int main()
{
int arr[10] = {10,9,8,7,6,5,4,3,2,1};
int sz = sizeof(arr) / sizeof(arr[0]);//数组长度
int i;
for (i = 0; i < sz - 1; i++)//趟数
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)//比较次数
{
if (arr[j] > arr[j + 1])//前面大于后面，交换
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
for (i = 0; i < sz; i++)//打印数组
{
printf("%d ", arr[i]);
}
}
模拟实现qsort排整型数组（利用冒泡排序方式）
主函数
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
bubble_qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
模拟qsort函数
将冒泡排序的实现copy过来，然后对其修改
大概替换的思想是
`void bubble_sort(void* base, int num, int width, int cmp)
{int i;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (比较函数的返回值)
{交换数组元素的函数}
}
}
}
比较函数compare(这里因为要排的是整型数组，用上面整型数组的比较函数就行)
int cmp(const void* p1, const void* p2)
{
return ((int)p1 - (int)p2);
}
现在的问题是怎么使用bubble_sort函数的参数找到要比较两个元素的地址？？
代码：
cmp((char*)base+j*width),(char*)base+(j+1)*width)>0
问题1：为什么要将base地址存在char的指针中？
方便访问任意类型数据，因为width是一个元素的字节大小，如果访问一个整型的地址，width就是4，char的指针+4刚好跳过4个字节，如果把base地址用int*接收，如果width还是4的话，+4就跳过的不是一个元素，而是4个元素，相邻的元素根本就比不了大小。
如果j=0的话，上面传到比较函数中的就是第一个元素地址和第二个元素地址
替换后的bubble_sort
void bubble_sort(void* base, int num, int width, int cmp)
{
int i;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
{
交换数组元素的函数
}
}
}
}
}
现在的问题是怎么交换两个地址上的元素。
交换数组元素的函数
void swap(char* p1, char* p2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *p1;
*p1 = *p2;
*p2 = tmp;
p1++;
p2++;
}
}
这里的交换函数是按字节交换的,比如说数组前两个元素1，3，假如说内存为小端存储，实现前两个元素交换
替换后的bubble_sort
void bubble_sort(void* base, int num, int width, int cmp)
{
int i;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base + j * width), (char*)base + (j + 1) * width)> 0)
{
swap((char*)base + j * width), (char*)base + (j + 1) * width));
}
}
}
}
}
整体代码展示
`#include <stdio.h>
int cmp(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}
void swap(char* p1, char* p2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *p1;
*p1 = *p2;
*p2 = tmp;
p1++;
p2++;
}
}
void bubble_sort(void* base, int num, int width, int cmp(const void* p1, const void* p2))
{
int i;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)> 0)
{
swap((char*)base + j * width,(char*)base + (j + 1) * width,width);
}
}
}
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}`
总结
希望这篇文章可以给你带来帮助，如果有不对的地方，或者有哪里不理解的地方，请私信我，谢谢大家支持，下篇见，以上