【C语言】函数指针|函数指针数组|函数指针数组指针|如何理解？

最新推荐文章于 2024-09-28 17:14:51 发布
最新推荐文章于 2024-09-28 17:14:51 发布
阅读量2.4k 收藏 25
点赞数 7
分类专栏： C语言 文章标签： c语言 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64538862/article/details/128668576
版权

目录

1.函数指针

1.1函数指针定义

 1.2使用函数指针实现简单计算器

2.函数指针数组

3.函数指针数组指针

4.回调函数

4.1回调函数的定义

4.2库函数qsort的使用

4.3模拟qsort实现冒泡排序

1.函数指针

1.1函数指针定义

数组指针：指向数组的指针

类比数组指针，可以得到函数指针：指向函数的指针

以下我们以加法函数Add为例讲解函数指

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 3;
	int b = 5;
	int ret = Add(a, b);
	
	return 0;
}

上述为一个加法函数Add，我们使用Add(a,b)调用，可以得到a+b的结果

我们已经知道如何定义一个数组指针

int arr[10] = {1,2,3,4,5,6,7,8,9,0}

int (*pa)[10] = &arr; 

类比数组指针，我们定义一个函数指针pf：

int (*pf)(int int) = &Add：pf指向函数Add

定义一个函数指针后，我们如何使用呢？ 

如下图所示：我们使用*pf(a,b)和pf(a,b)都可以调用成功

因为函数名和pf一样都可以表示函数的地址，Add(a,b)可以成功调用，pf(a,b)同理

 1.2使用函数指针实现简单计算器

以下代码是我们最初的构想：

#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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
int main()
{
	int input = 0;
	int a = 0;
	int b = 0;
	int result = 0;
	do
	{
		meau();//调用菜单函数
		printf("请选择要执行的操作>\n");
		scanf("%d", &input);
		
		switch (input)
		{
		case 0:
			printf("退出计算\n");
			break;
		case 1:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = Add(a, b);//执行加法
			printf("结果是：%d\n", result);
			break;
		case 2:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = sub(a, b);//执行减法
			printf("结果是：%d\n", result);
			break;
		case 3:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = mul(a, b);//执行乘法
			printf("结果是：%d\n", result);
			break;
		case 4:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = div(a, b);//执行除法
			printf("结果是：%d\n", result);
			break;
		default:
			printf("输入错误，重新输入>\n");
			break;
		}
	} while (input);
	

	return 0;
}

 以下是程序运行结果：

以上代码可以实现加减乘除简易计算器的计算，但是我们可以发现在switch-case语句中存在大量的代码冗余，我们应当尽量避免这种写法，所以我们使用函数指针来改进：

冗余代码：

printf("请输入俩个操作数>\n");
scanf("%d %d", &a, &b);
result = Add(a, b);//执行加法


printf("结果是：%d\n", result);

对于冗余的代码，我们可以把它封装成一个函数calc：

函数的返回类型是viod，因为我们已经在函数内部进行了结果的打印

那函数的参数是什么呢？

不难发现，冗余代码中只有调用的函数不同，所以我们的参数应该和函数有关才可以调用

如何找到一个函数，那当然就是通过函数指针啦

所以参数就是一个函数指针，并且这个指针指向的函数们返回类型类型，参数都一致

定义如下：

void calc(int* pf(int, int))
{
	printf("请输入俩个操作数>\n");
	scanf("%d %d", &a, &b);
	result = pf(a, b);//函数调用
	printf("结果是：%d\n", result);
}

有了calc函数，只需要在case语句中调用calc函数，并传参数为标号所对应的函数名即可

具体实现如下：

#define _CRT_SECURE_NO_WARNINGS 1
#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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
void calc(int* pf(int, int))
{
	int a = 0;
	int b = 0;
	printf("请输入俩个操作数>\n");
	scanf("%d %d", &a, &b);
	int result = pf(a, b);//执行加法
	printf("结果是：%d\n", result);
}
int main()
{
	int input = 0;
	do
	{
		meau();//调用菜单函数
		printf("请选择要执行的操作>\n");
		scanf("%d", &input);

		switch (input)
		{
		case 0:
			printf("退出计算\n");
			break;
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		default:
			printf("输入错误，重新输入>\n");
			break;
		}
	} while (input);


	return 0;
}

可以实现计算器的效果 

2.函数指针数组

函数指针数组：就是存放函数指针的数组

上述程序只能实现加减乘除四则运算，当我们需要实现更多的功能，例如x&y，x|y，x>>y，x<<y等一系列高级功能时，我们可以使用函数指针数组，以下还是以上个程序为基础介绍

#define _CRT_SECURE_NO_WARNINGS 1
#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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
int main()
{
	int input = 0;
	meau();	
	int (*parr[10])(int, int) = { 0,&Add,&Sub,&Mul,&Div };
	//多组输入
	do
	{
		printf("请输入要执行操作的序号\n");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算\n");
		}
		else if (input >= 1 && input <= 4)
		{
			int a = 0;
			int b = 0;
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			int result = parr[input](a, b);//函数调用
			printf("结果是：%d\n", result);
		}
		else
		{
			printf("输入错误，请重新输入\n");
		}
	} while (input);
	
	return 0;
}

首先我们参照整型数组理解一下函数指针数组

 

代码分析：

int (*parr[10])(int, int) = { 0,&Add,&Sub,&Mul,&Div };

//parr是一个函数指针数组

//为了使我们的输入与数组下标相对应，方便代码书写，0也参与数组的初始化
//当input == 0时执行，退出计算

if (input)

{
    printf("退出计算\n");
}

//当输入我们需要执行的操作的合法标号时执行
else if (input >= 1 && input <= 4)
{
    printf("请输入俩个操作数>\n");
    scanf("%d %d", &a, &b);
    int result = parr(input)(a, b);//函数调用

    //当input == 1时，result = parr[1] = &Add(a,b) = Add(a, b)

    //因为&Add和Add都表示函数的地址，所以这里可以完成函数调用
    printf("结果是：%d\n", result);
}

//输入其他非法数字时执行
else
{
    printf("输入错误，请重新输入\n");
}

3.函数指针数组指针

函数指针数组指针，顾名思义，就是指向函数指针数组的指针

首先，我们需要定义一个函数指针数组，如下

int (*pfarr[5])(int, int) = { 0 };

接着定义一个指针，指向这个数组

对于一个整型数组int arr[5] = { 0 };指向它的指针如下图所示

对于一个函数指针数组指针，首先它是一个指针，指向的数组有5个元素，每个元素的类型是int  (*) (int,int)

4.回调函数

4.1回调函数的定义

回调函数就是一个通过函数指针调用的函数。如果把一个函数指针（即函数的地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数，回调函数不是用该函数的实现方直接调用，而是在特定条件或者条件发生时由另外的一方调用的，用于对该事件或者条件的响应。

在上述使用函数指针实现计算器的例子中，类似calc(Add),calc(Sub)就是回调函数 

4.2库函数qsort的使用

库函数qsort：使用快速排序的思想实现的一个排序函数

我们使用cplusplus官网可以检索这个函数

官网地址：cplusplus.com - The C++ Resources Network

通俗来说，就是对于一个每个元素都是size类型的数组，我们从base指针指向的那个数开始，向后的num个数，按照compar指定的比较方式进行比较

 关于compar:首先这是一个函数指针，它指向的函数就是进行比较

可以这么认为：我们传给compar函数俩个参数a和b，compar函数处理并按照返回规则（如上图）返回一个整型数据，这个返回的数据作为库函数qsort函数的参数，qsort按其默认的顺序（默认升序）进行排序

另外，可以发现qsort函数和compar函数的参数类型都是const viod*类型，而不是某个具体的类型：其中，const用来保护数据，防止误操作造成程序错误

对于void*：viod*是一个没有具体类型的指针(可以称之为泛型指针)，可以接收任意类型的指针,因为函数提前不知道我们要操作的数据的类型,使用泛型指针，提高了函数的通用性

当然，泛型指针的特殊性导致其不能直接进行解引用操作，也不能进行+/-整数的操作

当我们使用时，需要先强制类型转换为我们需要的数据类型，再解引用操作

接下来我们使用qsort函数实现对结构体数据数据的排序

首先定义一个结构体类型，结构体成员变量包括了姓名，性别(male/female),年龄

struct Stu
{
	char name[10];
	char sex[10];
	int age;

};

接着我们在main函数中创建一个结构体数组进行初始化

int main()
{
	//结构体变量定义
	struct Stu s[] = { {"zhangsan","female",19 },{ "lisi","male",20 }, 
					   { "wangwu","female",18 },{ "zhouliu","male",20 } };
	//打印
	printf("%-10s %10s %10s\n", "姓名", "性别", "年龄");
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%-10s %10s %10d\n", s[i].name, s[i].sex, s[i].age);
	}
	return 0;
}

printf("%-10s %10s %10s\n", "姓名", "性别", "年龄");

%10s是一种打印格式：字符串占位符10位，默认右对齐

%-10s可以设置成左对齐

可以打印一下定义的结构体变量，检查赋值有无错误

然后使用sqort函数对结构体变量的成员排序

我们在主函数中加入俩行代码：

一行计算数组元素个数，即我们需要排序的元素个数

一行是qsort函数的调用，参数分别为：

  1. s：数组名即数组首地址，这里即表示我们从数组的第一个元素开始排序
  2. sz：数组的元素个数，这里表示需要排序的元素个数即为整个数组所有元素
  3. sizeof(s[0])：计算一个数组元素的大小，这里即表示待排序元素的大小
  4. compar_by_name：这是一个函数的地址，这个函数就是我们的比较方式
int main()
{
    //结构体变量定义
    int sz = sizeof(s) / sizeof(s[0]);//计算数组元素的个数
    qsort(s, sz, sizeof(s[0]), compar_by_age);
    //打印
}

接下来我们分别书写通过年龄，姓名和性别进行比较的函数 

  • 按照年龄排序
//年龄升序排列
int compar_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
	//*p1>*p2 返回>0
	//*p1==*p2 返回==0
	//*p1<*p2 返回<0

}
  • 按照姓名排序
//姓名的字符串升序排列
int compar_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}

因为strcmp函数的返回值刚好和比较函数的返回值符号相一致，所以我们可以不进行if语句的判断，直接将strcmp函数的返回值返回即可； 

  • 按照性别排序
//性别的字符串升序排列
int compar_by_sex(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->sex, ((struct Stu*)p2)->sex);

}

综上分析，我们可以写出以下完整代码

#define _CRT_SECURE_NO_WARNINGS 1//这行代码是避免VS编译器报scanf函数不安全的错误
#include<stdio.h>
#include<stdlib.h>//库函数qsort所需要的头文件
#include<string.h>
struct Stu
{
	char name[10];
	char sex[10];
	int age;

};
//年龄升序排列
int compar_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
//姓名的字符串升序排列
int compar_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
//性别的字符串升序排列
int compar_by_sex(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->sex, ((struct Stu*)p2)->sex);

}
int main()
{
	//结构体变量定义
	struct Stu s[] = { {"zhangsan","female",19 },{ "lisi","male",20 },
					   { "wangwu","female",18 },{ "zhouliu","male",20 } };
	int sz = sizeof(s) / sizeof(s[0]);//计算数组元素的个数
	qsort(s, sz, sizeof(s[0]), compar_by_age);
	//按其他方式比较只需要改变函数指针compar_by_age即可

	//打印
	printf("%-10s %10s %10s\n", "姓名", "性别", "年龄");
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%-10s %10s %10d\n", s[i].name, s[i].sex, s[i].age);
	}
	return 0;
}

4.3模拟qsort实现冒泡排序

 冒泡排序的基本原理我们已经讲解过，具体参考

https://mp.csdn.net/mp_blog/creation/editor/123819688

模拟qsort函数，所以我们的冒泡排序函数参数应与其一致

接下来我们进行函数传参

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	//这是一个降序数组，我们通过冒泡排序将其升序排列
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0], cmp));
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

bubble_sort(arr, sz, sizeof(arr[0], cmp));

其中，cmp 函数就是我们的比较函数

我们先编写 bubble_sort函数

和之前实现的冒排序函数一样，我们使用双层循环实现

不同的地方就是我们使用一个比较函数进行比较，如果不符合升序，则交换

交换也通过swap函数实现

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//外层循环控制冒泡排序的趟数
	for (i = 0; i < sz; i++)
	{
		int flag = 1;//默认数组有序
		int j = 0;
		//内层循环控制每一趟冒泡排序
		for (j = 0; j < sz - 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);
				flag = 0;//进行了交换，数组乱序则flag置为0
			}
		}
		//一次冒泡排序中没有进行交换，则数组有序,跳出循环
		if (flag == 1)
		{
			break;
		}

	}
}

 接着编写cmp比较函数

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);//升序排列，降序排列交换p1和p2即可
}

最后编写swap交换函数

void swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

注：关于cmp函数的参数和swap函数的参数

cmp(  (char*)base + j * width,  (char*)base + (j + 1) * width)

传参时，首先对base指针进行了强制类型转换，将base指针进行细化，使其可以每次访问一个字节（方便了char型数据的排序）；然后我们给它加了一个偏移量j+width，我们知道width是一个元素的大小，循环时，j从j=0开始，所以第一次比较函数比较的是(char*)base和(char*)base+width(整型数组时，width == 4);第二次比较函数比较的是(char*)base+width和(char*)base+2*width(整型数组时，width == 4)...我们画图解释

每次加一个偏移量使指针指向我们比较的位置 

如果不符合升序排列，就进行交换，调用swap函数

swap函数按每次访问一个字节的方式交换，因为我们在cmp函数中对指针进行了细化，所以这里每次交换一个字节，当元素为整型数据时，我们需要循环四次依次交换四个字节的数据

综上所述，整体代码如下

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
//swap函数按字节为单位交换两个元素
void swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//外层循环控制冒泡排序的趟数
	for (i = 0; i < sz; i++)
	{
		int flag = 1;//默认数组有序
		int j = 0;
		//内层循环控制每一趟冒泡排序
		for (j = 0; j < sz - 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);
				flag = 0;//进行了交换，数组乱序则flag置为0
			}

		}
		//一次冒泡排序中没有进行交换，则数组有序,跳出循环
		if (flag == 1)
		{
			break;
		}

	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	//这是一个降序数组，我们通过冒泡排序将其升序排列
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp);
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

输出如下：可以实现升序排列

 

李斯啦果
关注
专栏目录
C语言_函数指针之指针数组
qq_54357381的博客
01-19 752
C语言函数指针及函数指针数组
c语言函数指针具体作用,C语言-函数指针（Function Pointer）及进阶
weixin_29305337的博客
05-16 1543
前言初学C语言的童鞋，通常在学完函数和指针的知识后，已经是萌萌哒，学习到了函数指针(请注意不是函数和指针)，更是整个人都不好了，这篇文章的目的，就是帮助我的童鞋们理解函数指针。�函数指针概述首先我们需要回顾一下函数的作用：完成某一特定功能的代码块。再来回忆一下指针的作用：一种特殊的变量，用来保存地址值，某类型的指针指向某类型的地址。下面定义了一个求两个数最大值的函数：int maxValue (i...
C语言 函数指针，函数指针数组
m0_64885430的博客
05-01 236
函数指针：存放函数地址的指针。&函数名——取出的是函数地址 官方详解：在C语言中函数在内存中也占据一段连续的内存单元，函数名就是该函数所占内存区的首地址。可以把函数的这个首地址（或称入口地址）赋予一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。 类型说明符 （*指针变量名）（）； 例如：int （*pf）（int ，int）=&add； 浅看下下面例子来了解亿下函数指针 #include <stdio.h> int Add(int x
一篇文章了解【函数指针数组】
最新发布
m0_60605989的博客
09-28 560
C语言 - 对函数指针数组进行了简单的概述，并且举了相应的例子说明函数指针的具体用途。这是我的学习笔记，可能有不正确的地方，若有错误，还希望网友们指出，我加以改正。
C语言——函数指针——函数指针数组 （详解）
Jason_from_China的博客
03-11 3410
函数指针是指向函数的指针变量，可以用来调用相应的函数。函数指针数组的作用是可以根据需要动态地选择并调用不同的函数。其中，返回值类型是函数的返回值类型，指针数组名是函数指针数组的名称，数组大小是指针数组中元素的个数，参数列表是函数的参数类型和个数。函数指针是指向函数的指针变量，可以用来调用相应的函数。总之，函数指针数组提供了一种灵活的方式来选择并调用不同的函数，可以根据具体需求动态地改变函数的行为。使用函数指针数组时，可以通过索引来访问数组中的元素，并通过函数指针调用相应的函数。
C语言（函数指针数组）详解
热门推荐
Raikkonen_love的博客
08-23 1万+
指针，指针数组，数组指针，函数指针数组
c语言--函数指针数组
m0_64035128的博客
08-31 1059
指针函数数组
进阶C语言 - 指针（3）：函数指针数组
Fighting！！！
07-11 3128
函数指针数组的介绍。
指针进阶之函数指针和函数指针数组
01-07
函数指针和函数指针数组 函数指针是一种特殊的指针，它是指向函数的指针。函数指针可以用来存放函数的地址，并且可以通过函数指针来调用函数。 1. 简单介绍 函数指针是指向函数的指针，它可以用来存放函数的地址...
函数指针和函数指针数组的使用
08-03
函数指针和函数指针数组是C语言程序设计中的一种重要概念，它们可以解决实际程序编写过程中的多种情况问题。在本文中，我们将介绍函数指针和函数指针数组的概念、定义、使用方法，并探讨它们在实际编程中的应用。 ...
C语言 函数指针（指向函数的指针）详解
12-26
这种指针就是函数指针。 函数指针的定义形式为： returnType (*pointerName)(param list); returnType 为函数返回值类型，pointerNmae 为指针名称，param list 为函数参数列表。参数列表中可以同时给出参数的类型...
C语言函数指针小结C语言函数指针小结.doc
07-02
C语言函数指针小结 C语言函数指针是C语言中一个重要的组成部分，使用函数指针编程有以下优点： 1. 提高程序的编译效率和执行速度。 2. 通过函数指针可使用主调函数和被调函数之间共享变量或数据结构，便于实现...
C语言的函数指针数组
qq_46284844的博客
06-02 2767
简要介绍以下函数指针以及一些函数调用需要输入函数指针作为形参的情况。
函数指针数组
qq_45349785的博客
08-16 5560
本质它是一个数组； 提一个概念：圈复杂度 定义：圈复杂度用来衡量一个模块判定结构的复杂程度，数量上表现为线性无关的路径条数，即合理的预防错误所需测试的最少路径条数。圈复杂度大说明程序代码可能质量低且难于测试和维护，根据经验，程序的可能错误和高的圈复杂度有着很大关系。 函数指针数组可以有效降低圈复杂度。 函数指针数组的作用：转移表，回调函数。 举个栗子： 我们先写一个计算器的简单程序： #defin...
C语言_函数指针数组指针
cute_shuai的博客
11-23 578
函数指针数组指针？这是个啥玩意？第一次遇到我也是黑人问号脸，后来发现理解这个其实也不难，就是一个指向数组的指针而已，而这个数组里面的元素保存的是指向函数的指针。我们可以先从指针数组开始了解，由浅入深。
函数指针数组的定义
Sloan
06-05 1238
函数指针数组的定义方法，有两种：一种是标准的方法；一种是蒙骗法。 第一种，标准方法： { 分析：函数指针数组是一个其元素是函数指针的数组。那么也就是说，此数据结构是是一个数组，且其元素是一个指向函数入口地址的指针。 根据分析：首先说明是一个数组：数组名[] 其次，要说明其元素的数据类型指针:*数组名[]. 再 次，要明确这每一个数组元素是指向函数入口地址的指针：函数返回值类型(*数组名
数组指针、函数指针、指针数组、函数 指针数组、指针函数详细总结
wei_Embedded_z的博客
08-22 2970
数组指针、函数指针、指针数组、函数 指针数组、指针函数详细总结
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值