【C语言】指针进阶（下）

风里画沙_0

已于 2023-08-10 18:20:53 修改

阅读量62

点赞数

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

于 2023-08-10 14:37:01 首次发布

本文链接：https://blog.csdn.net/FZC206/article/details/132138191

版权

C语言专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章目录

七、指向函数指针数组的指针
八、回调函数
- 案列：qsort实现

七、指向函数指针数组的指针

定义：一个（指向（函数指针的）数组的）指针。

主要代码：

	//转移表
	//int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };//函数指针数组，0即NULL，空指针
	//定义一个指向函数指针数组的指针

	//1.首先,定义一个指向整形数组的指针pc1
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*pc1)[10] = &arr1;
	for (i = 0; i < 10; i++)
	{
		//printf("%d ", *((*pc1) + i));//两种方式都可以，详解见数组
		printf("%d ", (*pc1)[i]);
	}
	printf("\n");

	//2.然后类比,定义一个指向整形指针数组的指针pc2
	int a = 11;
	int b = 22;
	int c = 33;
	int* arr2[3] = { &a,&b,&c };
	int* (*pc2)[3] = &arr2;
	for (i = 0; i < 3; i++)
	{
		//printf("%d ", **((*pc2) + i));//前两个是一模一样的代码，第二行加（）只是为了层次清晰
		//printf("%d ", *(*((*pc2) + i)));
		printf("%d ", *((*pc2)[i]));//第三行这种写法，详见数组
	}
	printf("\n");

	//3.最后类比,定义一个指向函数指针数组的指针pc3
	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };//pfArr是一个函数指针数组，
	//这里再次提醒，对函数来说：  函数名 与 &函数名 无任何区别，效力同等，都表示函数地址
	int(*(*pc3)[5])(int, int) = &pfArr;//然后将这个数组的整个地址放入pc3
	//当然，在这里通过pc来使用函数，肯定得解引用，解引用就相当于找到了pfArr这个数组，然后通过[]或者再解引用调用具体的函数
	//如：
	printf("\n开始调用函数数组指针\n");
	for (i = 1; i < 5; i++)
	{
		ret = (*pc3)[i](3, 4);
		printf("%d ", ret);
	}
	printf("\n调用完毕！\n");

完整代码及执行结果

#include<stdio.h>

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
//
//
void menu()
{
	printf("**************************\n");
	printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	int i = 0;

	//转移表
	//int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };//函数指针数组，0即NULL，空指针
	//定义一个指向函数指针数组的指针

	//1.首先,定义一个指向整形数组的指针pc1
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*pc1)[10] = &arr1;
	for (i = 0; i < 10; i++)
	{
		//printf("%d ", *((*pc1) + i));//两种方式都可以，详解见数组
		printf("%d ", (*pc1)[i]);
	}
	printf("\n");

	//2.然后类比,定义一个指向整形指针数组的指针pc2
	int a = 11;
	int b = 22;
	int c = 33;
	int* arr2[3] = { &a,&b,&c };
	int* (*pc2)[3] = &arr2;
	for (i = 0; i < 3; i++)
	{
		//printf("%d ", **((*pc2) + i));//前两个是一模一样的代码，第二行加（）只是为了层次清晰
		//printf("%d ", *(*((*pc2) + i)));
		printf("%d ", *((*pc2)[i]));//第三行这种写法，详见数组
	}
	printf("\n");

	//3.最后类比,定义一个指向函数指针数组的指针pc3
	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };//pfArr是一个函数指针数组，
	//这里再次提醒，对函数来说：  函数名 与 &函数名 无任何区别，效力同等，都表示函数地址
	int(*(*pc3)[5])(int, int) = &pfArr;//然后将这个数组的整个地址放入pc3
	//当然，在这里通过pc来使用函数，肯定得解引用，解引用就相当于找到了pfArr这个数组，然后通过[]或者再解引用调用具体的函数
	//如：
	printf("\n开始调用函数数组指针\n");
	for (i = 1; i < 5; i++)
	{
		ret = (*pc3)[i](3, 4);
		printf("%d ", ret);
	}
	printf("\n调用完毕！\n");
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);

	return 0;
}

结果
在这里插入图片描述

八、回调函数

定义：通过函数指针调用的函数。
再次回顾该代码，不难发现switch函数代码显得过于冗余：

#include<stdio.h>

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
//
//
void menu()
{
	printf("**************************\n");
	printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			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;
}

	return 0;
}

故对这里的代码再定义一个新函数，通过传参来进行函数调用即可。

#include<stdio.h>

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}

void menu()
{
	printf("**************************\n");
	printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}

void calc(int(*pfA)(int, int))//回调函数，可以理解为将可以多个函数作为参数传入另外的函数来使用，但其本质是通过指针调用了实现，而不是复制函数。
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入两个操作数：");
	scanf("%d %d", &x, &y);
	ret = pfA(x, y);
	printf("%d\n", ret);
}

 int main()
{
	int input = 0;

	do
	{
		menu();
		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;
}

当然，回调函数的参数形式必须相同。

案列：qsort实现

引言

平常自己写的类似于下列代码的排序，只能是按一种类型排序，当排序的的条件变化是就得重新写符合要求的代码。

认识qsort

qsort是一个库函数，基于快速排序算法实现的一个排序的函数

qsort 在这里插入图片描述

函数分析：

体验qsort

#include <stdio.h>      
#include <stdlib.h>     /* qsort */
#include <string.h>     /* strcmp */
struct person
{
    char name[20];
    int age;
    double score;
};
int compare_name(const void* a, const void* b)
{
    //return ((struct person*)a)->name - ((struct person*)b)->name;//error,字符串比较得用strcmp函数
    return strcmp(((struct person*)a)->name, ((struct person*)b)->name);
}
int compare_age(const void* a, const void* b)
{
    //if (((struct person*)a)->age < ((struct person*)b)->age) return -1;
    //if (((struct person*)a)->age == ((struct person*)b)->age) return 0;
    //if (((struct person*)a)->age > ((struct person*)b)->age) return 1;
    //return 0;
    return ((struct person*)a)->age - ((struct person*)b)->age;
}
int compare_score(const void* a, const void* b)
{
    //if (((struct person*)a)->score < ((struct person*)b)->score) return -1;
    //if (((struct person*)a)->score == ((struct person*)b)->score) return 0;
    //if (((struct person*)a)->score > ((struct person*)b)->score) return 1;
    //return 0;
    return ((struct person*)a)->score - ((struct person*)b)->score;
}
struct person as[] = { {"zhansan",20,84.1},{"fuyong",16,89.0},{"lisi",24,88.1} };
int main()
{
    int n;
    int sz = sizeof(as) / sizeof(as[0]);
    qsort(as,sz, sizeof(as[0]), compare_name);
    for (n = 0; n < sz; n++)
        printf("%s\t%d\t%.2lf\n", as[n].name,as[n].age,as[n].score);
    return 0;
}

实现qsort

用冒泡排序模拟qsort函数

//模拟qsort
void swap(char* a, char* b, int sz)
{
    while (sz > 0)
    {
        char tmp = *a;
        *a = *b;
        *b = tmp;
        a++; b++;
        sz--;
    }
}
void my_qsort(void* base,int sz,int width, int (*compar)(const void* a, const void* b))
{
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            if(compar(((char*)base + j * width), ((char*)base + (j+1) * width))>0)
            {
                swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
            }
        }
    }
}

风里画沙_0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【C语言】指针进阶（下）

平常自己写的类似于下列代码的排序，只能是按一种类型排序，当排序的的条件变化是就得重新写符合要求的代码。故对这里的代码再定义一个新函数，通过传参来进行函数调用即可。是一个库函数，基于快速排序算法实现的一个排序的函数。定义：一个（指向（函数指针的）数组的）指针。当然，回调函数的参数形式必须相同。定义：通过函数指针调用的函数。
复制链接

扫一扫

专栏目录