【指针进阶（2）】||【函数指针、函数指针数组、回调函数】重点剖析+代码详解

最新推荐文章于 2023-01-17 22:14:27 发布
最新推荐文章于 2023-01-17 22:14:27 发布
阅读量186 收藏
点赞数
分类专栏： c 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57987831/article/details/118073204
版权

 

       怠惰是贫穷的制造厂。

目录

​

 

函数指针

1.函数指针的定义形式：

2.函数的调用

3.解析两段有趣的代码：

函数指针数组

1.定义形式

2.函数指针数组的用途

指向函数指针数组的指针

回调函数

1.qsort函数

2.qsort函数的应用：

3.模拟实现qsort(采用冒泡排序的方式）

函数指针

一个函数总是占用一段连续的内存区域，函数名在表达式中可以被转换成所在区域的首地址，我们可以把函数的这个首地址赋予一个指针变量，使其指向函数所在的内存区域，然后通过指针变量就可以找到并调用这个函数，这种指针就是函数指针。

1.函数指针的定义形式：

returnType  (*pointerName)  (param list);

返回类型（*指针名称）（函数参数）

eg:void  (*p) (int)

注：（）优先级高于* ，第一个括号不可省略

 &函数名和 函数名，都是函数地址，这点与数组不同。

2.函数的调用

3.解析两段有趣的代码：

1.

（*（void (*)() )  0)( ) ;

 2.

void( *signal ( int , void(*)(int) )   ) (int); 
解析：首先，在一个变量的定义形式中，我们去掉它的变量名，剩下的就是它的类型。例如：

int a;  ----- a 是int型

char ch;----ch是char型

int* b;-----b是int*型，即b是个指针变量；

int *arr[10]; -----arr是int* [10]型，即arr是个指针数组

int （*p)[10];------p是int (*)[10]型，即p是一个数组指针

void (*p)();----------p是void(*)()型，即p是一个函数指针

1.

2.

代码二实在是太复杂，我们可以简化一下

我们前边说过，signal的函数返回类型为void(*)(int),这个太长读起来有些难懂，我们就把它类型重定义一下；

你可能觉得它应该是长这个样子的，

typedef void(*)(int)  pfun_t;

很遗憾，不是噢，这个新的函数类型名字需要紧跟这星号*，是这个样子滴

typedef void(*pfun_t)(int);

然后，这段冗长的代码就可以改成：

pfun_t signal(int, pfun_t);

 

 

函数指针数组

1.定义形式

数组是一个存放相同类型数据的存储空间，我们已经学习过了指针数组：

int *arr[10];数组的每个元素是int*,是个指针

那我们如果要把几个函数的地址存在一个数组里，那这个数组就叫做函数指针数组。定义形式如下：

int (* arr[7]) ( int );

arr先和[ ]结合，表明是一个数组，数组有7个元素，每个元素都是int(*)()即函数指针类型。

2.函数指针数组的用途

那他到底有什么用呢？

我们先用一段代码来实现一下计算器：

#include<stdio.h>

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

}
int add(int a, int b)
{
    int z = a + b;
    return z;
}
int sub(int a, int b)
{
    int z = a - b;
    return z;
}
int mul(int a, int b)
{
    int z = a * b;
    return z;
}
int div(int a, int b)
{
    int z = a / b;
    return z;
}
int main()
{
    int input = 0;
    int x = 0;
    int y = 0;

    do
    {
        menu();
        printf("请选择->");
        scanf("%d", &input);
        switch (input)
        {
        case 0:
            printf("退出");
            break;
        case 1:
            printf("请输入你的操作数");
            scanf("%d%d", &x, &y);
            printf("%d\n",add(x,y));
            break;
        case 2:
            printf("请输入你的操作数");
            scanf("%d%d", &x, &y);
            printf("%d\n", sub(x, y));
            break;
        case 3:
            printf("请输入你的操作数");
            scanf("%d%d", &x, &y);
            printf("%d\n", mul(x, y));
            break;
        case 4:
            printf("请输入你的操作数");
            scanf("%d%d", &x, &y);
            printf("%d\n", div(x, y));
            break;
        default:
            printf("输入错误");
        }

    } while (input);
    return 0;
}

利用回调函数（后边会讲），做一下优化

void menu()
{
	printf("*********************************\n");
	printf("***1.add********2.sub************\n");
	printf("***3.mul********4.div************\n");
	printf("*********0.exit******************\n");
	printf("*********************************\n");
	printf("*********************************\n");
}
int add(int x, int y)
{
	int z = 0;
	return z = x + y;
}
int sub(int x, int y)
{
	int z = 0;
	return z = x - y;
}
int mul(int x, int y)
{
	int z = 0;
	return z = x * y;
}
int div(int x, int y)
{
	int z = 0;
	return z = x / y;
}
void caluc(int(*p)(int,int))
{
	int x = 0;
	int y = 0;
	printf("请输入您的数字");
	scanf("%d%d", &x, &y);
	printf("%d\n", p(x, y));
	
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 0:printf("退出\n");
			break;
		case 1:
			caluc(add);
			break;
		case 2:
			caluc(sub);
			break;
		case 3:
			caluc(mul);
			break;
		case 4:
			caluc(div);
			break;
		default:
			printf("输入错误\n");
			break;
		}
	
	} while (input);
	return 0;
}

我们也可以运用函数指针数组来实现：

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

}
int add(int a, int b)
{
    int z = a + b;
    return z;
}
int sub(int a, int b)
{
    int z = a - b;
    return z;
}
int mul(int a, int b)
{
    int z = a * b;
    return z;
}
int div(int a, int b)
{
    int z = a / b;
    return z;
}
int main()
{
    int input = 0;
    int x = 0;
    int y = 0;
    int(*parr[5])(int, int) = {0,add,sub,mul,div};
    do
    {
        menu();
        printf("请选择->");
        scanf("%d", &input);
        
        if (input >= 1 && input <= 4)
        {
            printf("请输入操作数：");
            scanf("%d%d", &x, &y);
            printf("%d\n", parr[input](x, y));
        }
        else if (0 == input)
        {
            printf("退出\n");            
        }
        else
        {
            printf("录入有误\n");
        }

    } while (input);
    return 0;
}

函数指针数组的用途：转移表。

指向函数指针数组的指针

 

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针。那是如何定义的呢？

void（*p）(int ,int);-----------这是一个函数指针

void（*parr[4]）(int ,int);---------这是一个函数指针数组；

void（*（*pparr）[4]）(int ,int);---------这是一个指向函数指针数组的指针；

回调函数

回调函数是一个通过函数指针调用的函数，如果你把函数的地址作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

最著名的回调函数调用有C/C++标准库stdlib.h/cstdlib中的快速排序函数qsort和二分查找函数bsearch中都会要求的一个与strcmp类似的参数，用于设置数据的比较方法。

1.qsort函数

首先，我们先了解一下qsort函数：

qsort 是qsort函数C语言编译器函数库自带的排序函数。

 

函数声明：
void qsort (void* base, size_t num, size_t size,
            int (*compar)(const void*,const void*));

base:要进行排序数组的首元素地址

num:数组元素个数

size:数组每个元素的大小，以字节为单位

compar:函数指针，指向一个比较两个元素的函数，这个函数使用者自己实现

compar参数

int compar(const void* p1,const void*p2)

Compare 函数的返回值

描述

< 0

p1将被排在p2前面

0

p1 等于 p2

> 0

p1 将被排在p2后面

补充：关于void:

1.void* 类型指针能接受任何类型的地址

2.void*类型指针不能进行解引用

3.void*类型指针不能进行+-加减整数操作

2.qsort函数的应用：

1.对浮点型数据进行排序


int float_cmp(const void*p1, const void* p2)
{
	return( int )(*(float*)p1 - *(float*)p2);
}
int main()
{
	float arr[] = { 9.0, 8.0, 7.0, 6.0, 5.0, 4.0 };
	int sz =sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz,sizeof(float), float_cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%lf ", arr[i]);
	}
 return 0；
}

2，对整型进行排序

int int_cmp(const void*p1, const void*p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int main()
{
	int i = 0;
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(int),int_cmp);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

3.对结构体进行排序

struct stu
{
	char name[20];
	int age;
};
int struct_name_cmp(const void*p1, const void*p2)
{
	return strcmp(  ( (struct stu*)p1 )->name,( (struct stu* )p2)  ->name);
}
int struct_age_cmp(const void*p1, const void*p2)
{
	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}

int main()
{
	struct stu class1[3] = { { "zhangsan", 20 }, { "lisi", 33 }, { "wangwu", 67 } };
	int sz = sizeof(class1) / sizeof(class1[0]);
	qsort(class1, sz, sizeof(class1[0]), struct_name_cmp);
	qsort(class1, sz, sizeof(class1[0]), struct_age_cmp);
	return 0;
}

1）.原序列

2）按名字排序

3）按年龄排序

总结;

我们把cmp这个回调函数的地址传给了qsort函数，实现了数列排序中两个元素大小的比较。使用qsort函数进行排序，要比我们之前所采用的冒泡排序适用范围更广。我们之前采用的只能对整型数组进行排序，具有局限性。

冒泡排序（只能对整型进行排序）

void bubble_sort(int arr[], int sz)
{
	int i = 0;//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			int tmp = 0;
			if (arr[j]>arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);

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

}

3.模拟实现qsort(采用冒泡排序的方式）

int int_cmp(const void*p1, const void*p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int float_cmp(const void*p1, const void* p2)
{
	return( int )(*(float*)p1 - *(float*)p2);
}
struct stu
{
	char name[20];
	int age;
};
int struct_name_cmp(const void*p1, const void*p2)
{
	return strcmp(  ( (struct stu*)p1 )->name,( (struct stu* )p2)  ->name);
}
int struct_age_cmp(const void*p1, const void*p2)
{
	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}
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(void* base, int count,int width, void*(*cmp)(void*,void*))
{
	int i = 0;
    //趟数
	for (i = 0; i < count - 1; i++)
	{
    	int j = 0;
       //每一趟需要比较的对数
		for (j = 0; j < count - 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 );
			}
		}
	}
}
void test2()
{
	struct stu s[3] = { {"zhangsan",20},{"lisi",19},{"wangwu",77} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof(s[0]), struct_name_cmp);
}
void test1()
{
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz, sizeof(int), int_cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	//test1();
	test2();
	return 0;
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Sobtemesa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在c语言函数调用中用指针操作数组
qq_44879626的博客
08-18 1963
直接上代码 #include<iostream> using namespace std; int p[20]; void change(int *p){ for(int i = 1; i <= 8; i++) p[i] = 1; } int main(){ change(p); for(int i = 0; i < 20; i ++) cout << p[i] << ' '; return 0; } 输出为 0 1
一线研发之声：嵌入式C编程经验之函数指针
08-20
函数指针在Linux内核中的应用非常广泛，例如在驱动程序中，函数指针用于回调函数的实现。回调函数是一种高效的方式，能够使得程序更加模块化和灵活。 在嵌入式系统中，函数指针的应用非常广泛，例如在M0/M3平台中，...
函数利用指针调用全部数组
qq_41259353的博客
12-01 838
//使用静态变量进行返回  #include&lt;stdio.h&gt; //定义产生数组的函数  double *TestFuction();   double main() {     double *p;     int i;     p = TestFuction();          for (i=0;i&lt;5;++i)     {         printf("%f\n", ...
指针数组综合使用（函数调用）
weixin_42989738的博客
01-09 4322
这个是参考谭浩强的C语言写的，并对该程序进行充分解释，因为最近我需要用到这块的综合使用，因此需要对这些内容进行详细解读，可能有很多地方没有读懂，大家可以一起看看。 **题目：就是对一组字符串进行排序，采用冒泡法进行，并要求使用指针和调用函数，**后买你需要用到从文件中读取数据，然后进行字符分割，从而通过冒泡排序进行结果显示，最后需要以二进制的形式写在另一个文档中，这个目前还不会，不过正在学习。 #...
函数指针数组——学习——对函数的调用
yuyantai1234的专栏
02-27 762
近来在学习展讯平台，看到一些代码，值得学习，所以摘下来，以做笔记。 如下： 函数指针数组s_key_function[][]; const DCKEYFUNCTION s_key_function[DC_KEY_MAX][DC_FLOW_MODE_MAX] = { /*DC_PREVIEW CONT_DOWN DC_CAPTURE DC_REVIEW
函数指针数组
vinnyjia的博客
04-13 313
函数指针数组：数组中的每一个元素都是函数指针。 函数指针调用函数的方法： void fun(int a) { } void(*pfun)(int)=fun; //第一种方法 pfun(1); //第二种方法 （*pfun）(2); 函数指针数组： #include #include void fun1(int a) { printf("fun1:%d\n", a)
Python回调函数用法实例详解
12-25
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的...
Java 回调函数深入理解
08-31
总的来说，Java回调函数通过接口和对象的交互，实现了代码间的协作，让服务程序可以在特定时刻调用客户程序提供的逻辑，极大地增强了程序的灵活性和可扩展性。理解并熟练运用回调函数是成为高级Java开发者的必备技能...
C语言 指针与数组的详解及区别
01-01
C语言 指针与数组的详解及对比 通俗理解数组指针和指针数组 数组指针： eg:int( *arr)[10]; 数组指针通俗理解就是这个数组作为指针，指向某一个变量。 指针数组： eg:int*arr[10]; 指针数组简言之就是存放指针的数组...
一文让你不再害怕指针之C指针详解(经典,非常详细)
12-25
前言:复杂类型说明 要了解指针,多多少少会... //首先从P 处开始,先与*结合,所以说明P 是一个指针,然后再与int 结合,说明指针所指向的内容的类型为int 型.所以P是一个返回整型数据的指针 int p[3]; //首先从P 处开始,先
C语言——函数指针 数组指针 指针数组 指针的指针
qq_45166999的博客
07-31 1143
函数指针： 在c语言中，一般函数都是占用一段连续的内存区，而函数名就是这段连续内存区的首地址，而且指针也代表着地址。所以，我们可以吧函数名（函数首）赋值给指针变量，用指针来调用这个函数。 格式：int （*p）() :表示指针p指向一个无形参，且返回值是int型的函数。 p(); :调用时的格式。 注：int (*p)() 中（ *p ) 的括号必须要加，不然像int *...
C语言函数调用之数组与指针
Lyttt的博客
04-02 5064
数组：数组是用于存储多个相同的数据类型的一片连续的内存空间，其数组名代表这段空间的首地址 指针：指针也是一个变量，但是与别的变量不一样，它存放的是另一段内存的首地址 在这里我们需要注意数组名就是数组的首地址，而指针是存放的是地址，那就意味着在一些情况下指针和数组是可以替换使用的。但要注意的是，数组名永远都是指向这段内存空间的首地址，它是不能指向别的地址。如：int array[3] 中的array可以看作是int *const array类型的指针。既然说数组名就是数组的首地址，那么数组在传地址的时.
指针（中）——传参，函数指针，函数指针数组，指向函数指针数组的指针
weixin_58843717的博客
08-21 454
目录 1.数组传参，指针传参 （一）一维数组传参 （二）二维数组传参 （三）一维指针传参 (四）二级指针传参 2.函数指针 函数地址的存储： 函数的调用： 强化练习，理解两段代码 3.函数指针数组 函数指针数组的定义 函数指针数组的实现 4.指向函数指针数组的指针 定义 1.数组传参，指针传参 在写代码的时候难免要把【数组】或者【指针】传给函数，其中要注意传数组，就必须用数组接收，传指针就必须用指针接收。 （一）一维数组传参 ...
C语言指针详解（有qsort模拟实现）
weixin_61392399的博客
01-21 602
指针总结+qsort模拟实现进来看
深度理解函数和指针，利用回调函数模拟实现qsort
IronMan240的博客
05-25 252
函数指针：#include &lt;stdio.h&gt; void test() { ; } int main() { printf("%p\n", test); printf("%p\n", &amp;test); return 0; } 从输出结果可以看出test函数的地址被打印了出来，而且 test 和 &amp;test 结果一样。既然函数有地址，那么就可以将地址用指针保存...
【C语言】函数指针|函数指针数组|函数指针数组指针|如何理解？
最新发布
m0_64538862的博客
01-17 2327
【C语言】函数指针|函数指针数组|函数指针数组指针|如何理解？函数指针实现简易计算器|库函数qsort|使用sqort函数对结构体变量的成员排序|模拟qsort实现冒泡排序|泛型指针|结构体数组
浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解
weixin_55719365的博客
03-18 1033
回调函数 官方定义： 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数 的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。 代码解释： #include<stdio.h> void test() { printf("HaHaHa"); } void print(void (*pr)())//创建一个函数指针接受t
C语言：数组指针&函数指针&回调函数
qq_45481606的博客
01-12 1035
0是一个整数，先强转成函数的地址，（对函数的地址解引用就是函数）再解引用变成了函数，再加括号调用该函数。调用地址为0的函数，但0不能当做一个地址，所以将0强转为void(*)()类型的函数。*的结合优先级低于( )和 [ ]。
C语言-指针与数组
huangjiaaaaa的博客
02-17 401
前面已经介绍了指针的基本知识，现在我们将指针与数组结合起来运用。 我们都知道，C语言中定义的数组，在内存中的地址是连续的，比如定义了一个数组 int a[5] 那么a[5]的首地址可以用a或者&a[0]表示 如果我们创建一个指针p，并将p指向数组a的首地址 int *p; p=&a[0];//数组a的首地址为&a[0]或a,将p指向数组a的首地址 那么接下来要对数组a...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值