• 深入理解指针：【探索指针的高级概念和应用二】

    目录

    一，数组参数、指针参数

    1.一维数组传参

    2.二维数组传参

    3.一级指针传参

    4.二级指针传参

    二，函数指针

    三，函数指针数组

    🍂函数指针数组的用途（转移表）： 

    四，指向函数指针数组的指针

    一，数组参数、指针参数

    我们在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？下面我们就一起来探究一下。

    1.一维数组传参

    1. #include 
    2. //数组传参，形参是可以写成数组形式的，因为这儿传参的本质是数组首元素的地址，所以大小可以不写
    3. void test(int arr[])
    4. {}
    5.  
    6. //这儿不会去创建一个新的数组，这个大小是无意义的，所以数组里边的大小也可以省略
    7. void test(int arr[10])
    8. {}
    9.  
    10. //数组传参的本质是传递数组首元素的地址；数组传参，形参也可以是指针
    11. void test(int* arr)
    12. {}
    13.  
    14. //数组传参，形参用数组形式，数组的大小也可以省略
    15. void test2(int* arr2[20])
    16. {}
    17.  
    18. //arr2的每个元素类型都是int*，这儿传过来的是首元素地址，即第一个元素的地址（int*的地址），
    19. //所以就是将一级指针的地址取出来放在二级指针里边去
    20. void test2(int** arr2)
    21. {}
    22.  
    23. int main()
    24. {
    25. 	int arr[10] = { 0 };//定义了一个一维数组，数组里边有10个元素，每个元素是int类型
    26. 	int* arr2[20] = { 0 };//数组里边有20个元素，每个元素是int*类型
    27. 	test(arr);
    28. 	test2(arr2);
    29. }

    2.二维数组传参

    1. //数组传参，形参的部分写成数组
    2. void test(int arr[3][5])
    3. {}
    4.  
    5. //错误写法
    6. //数组传参的时候，行可以省略，但是列绝对不能省略
    7. void test(int arr[][])
    8. {}
    9.  
    10. //正确写法
    11. void test(int arr[][5])
    12. {}
    13.  
    14. //错误写法
    15. //数组名表示首元素的地址，即第一行的地址；而这是一个整型指针，
    16. //整型指针是用来接受整型变量的地址的，所以这种写法是错误的
    17. void test(int* arr)
    18. {}
    19.  
    20. //错误写法
    21. //二维数组传过来拿指针数组接收了，应该用数组指针接收
    22. void test(int* arr[5])
    23. {}
    24.  
    25. //正确写法
    26. //这是一个数组指针，指向5个元素，每个元素是int类型，它可以指向数组中的第一、二、三行
    27. void test(int(*arr)[5])
    28. {}
    29.  
    30. //错误写法
    31. //二级指针是用来接收一级指针的地址的
    32. void test(int** arr)
    33. {}
    34.  
    35. int main()
    36. {
    37. 	int arr[3][5] = { 0 };//定义了一个三行五列的二维数组
    38. 	test(arr);//对数组进行传参
    39. }

    🍂总结：

    二维数组传参，函数形参的设计只能省略第一个[ ]的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。

    3.一级指针传参

    1. #include 
    2. //一级指针传参的时候形参的部分写成一级指针就可以
    3. void print(int* p, int sz)
    4. {
    5. 	int i = 0;
    6. 	for (i = 0; i < sz; i++)
    7. 	{
    8. 		printf("%d\n", *(p + i));//访问数组的每个元素
    9. 	}
    10. }
    11. int main()
    12. {
    13. 	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
    14. 	int* p = arr;//将数组的数组名赋给了p，本质是将数组首元素的地址赋给了p
    15. 	int sz = sizeof(arr) / sizeof(arr[0]);
    16. 	
    17. 	print(p, sz);//一级指针p，传给函数
    18. 	return 0;
    19. }

    🌴我们可以思考一下当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

    1. void test(int* p)
    2. {
    3.  
    4. }
    5.  
    6. int a = 10;
    7.  
    8. test(&a);//传整型变量的地址
    9.  
    10. int* ptr = &a;
    11. test(ptr);//传整型指针
    12.  
    13. int arr[5];
    14. test(arr);//传整型一维数组的数组名

    4.二级指针传参

    1. #include 
    2. void test(int** ptr)//二级指针传过来拿二级指针接收
    3. {
    4. 	printf("num = %d\n", **ptr);
    5. }
    6. int main()
    7. {
    8. 	int n = 10;
    9. 	int* p = &n;
    10. 	int** pp = &p;
    11. 	test(pp);//把pp这个二级指针传给test函数
    12. 	test(&p);//p是一级指针变量，&p也是二级指针
    13. 	return 0;
    14. }

    🌴我们再思考一下当一个函数的参数部分为二级指针的时候，函数能接收什么参数？ 

    1. void test(int** p)
    2. {
    3.  
    4. }
    5.  
    6. int main()
    7. {
    8. 	int n = 10;
    9. 	int* p = &n;
    10. 	int** pp = &p;
    11. 	int* arr[6];
    12.  
    13. 	test(&p);
    14. 	test(pp);
    15. 	test(arr);//数组名表示首元素的地址，就是int*的地址，传参后要用二级指针来接收
    16. 	return 0;
    17. }

    二，函数指针

    我们知道数组指针是指向数组的指针，存放的是数组的地址，&数组名就是数组的地址；

    那函数指针就是指向函数的指针，存放的是函数的地址，那怎么才能得到函数的地址呢？是不是&函数名呢？接下来我们通过一段代码来探究一下函数指针的神秘面纱：

    1. int Add(int x, int y)
    2. {
    3. 	return x + y;
    4. }
    5. int main()
    6. {
    7. 	//&函数名就是函数的地址
    8. 	//函数名也是函数的地址
    9. 	printf("%p\n", &Add);
    10. 	printf("%p\n", Add);
    11.  
    12. 	return 0;
    13. }

    🎈输出结果： 

    我们可以看到输出的是两个相同的地址，而这两个地址都是Add函数的地址 ，所以&函数名和函数名都能得到函数的地址。那我们的函数想要保存起来，该怎么做呢？看代码：

    1. int Add(int x, int y)
    2. {
    3. 	return x + y;
    4. }
    5. int main()
    6. {
    7. 	int (*pf1)(int, int) = &Add;//pf1就是函数指针变量
    8.  
    9. 	int ret = (*pf1)(3, 5);//通过函数指针变量找到函数地址并且调用它
    10.     printf("%d\n", ret);
    11.  
    12. 	return 0;
    13. }

    上面代码中的pf1是函数指针变量，它可以将我们的函数保存起来，pf1先和*结合，说明pf1是指针，指针指向的是一个函数，指向的函数有两个int类型的参数，返回值类型为int类型。

    🍂 接下来我们再阅读两段有趣的代码（出自：《C陷阱和缺陷》）：

    🍃代码一：

    1. int main()
    2. {
    3. 	( *(void (*)())0 )();
    4.  
    5. 	return 0;
    6. }

    在上面这段代码中我们从最熟悉的0开始下手，0是个数字；0前面的void (*)()这部分是指针指向了一个函数，函数没有参数，返回类型是void，所以这部分是一个函数指针类型；将类型放在括号里边就是要强制类型转换，转换完后前面加个*，就是要解引用，去调用这个函数，调用的这个函数也没有参数；

    总结起来就是上面这段代码是在调用0地址处的函数，这个函数没有参数，返回类型是void。

    🍃代码二：

    1. int main()
    2. {
    3. 	void (*signal(int, void(*)(int)))(int);
    4.  
    5. 	return 0;
    6. }

     上面这段代码比较复杂，我们可以将它简化为以下两部分

    1. void (*  )(int);
    2.  
    3. signal(int, void(*)(int));

    现在我们再来看这段代码就比较好分析了，首先它是一次函数声明，声明的是signal函数，signal 函数的参数有两个，第一个是int 类型，第二个是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void；signal函数的返回类型也是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void。

    三，函数指针数组

    通过前面的学习我们知道数组是一个存放相同类型数据的存储空间，例如指针数组：

    int* arr[10];

     这是一个整型指针数组，存放的是整型指针，数组的每个元素是int*。

    由上边的例子我们就可以知道函数指针数组也是一个数组，它存放的是函数指针（即函数的地址 ）：

    1. int (*parr1[10])();
    2. //parr1 先和 [] 结合，说明 parr1是数组，
    3. //数组的内容是int (*)() 类型的函数指针

    🍂函数指针数组的用途（转移表）： 

    🌴例子（计算器）：

    1. void menu()
    2. {
    3. 	printf("************************\n");
    4. 	printf("***  1.Add    2.Sub  ***\n");
    5. 	printf("***  3.Mul    4.Div  ***\n");
    6. 	printf("***  0.exit          ***\n");
    7. 	printf("************************\n");
    8. }
    9.  
    10. int Add(int x, int y)
    11. {
    12. 	return x + y;
    13. }
    14. int Sub(int x, int y)
    15. {
    16. 	return x - y;
    17. }
    18. int Mul(int x, int y)
    19. {
    20. 	return x * y;
    21. }
    22. int Div(int x, int y)
    23. {
    24. 	return x / y;
    25. }
    26.  
    27. int main()
    28. {
    29. 	int input = 0;
    30. 	int x = 0;
    31. 	int y = 0;
    32. 	int ret = 0;
    33. 	do
    34. 	{
    35. 		menu();
    36. 		printf("请选择:> ");
    37. 		scanf("%d", &input);
    38. 		switch (input)
    39. 		{
    40. 		case 1:
    41. 			printf("请输入操作数：");
    42. 			scanf("%d%d", &x, &y);
    43. 			ret = Add(x, y);
    44. 			printf("ret= %d\n", ret);
    45. 			break;
    46. 		case 2:
    47. 			printf("请输入操作数：");
    48. 			scanf("%d%d", &x, &y);
    49. 			ret = Sub(x, y);
    50. 			printf("ret= %d\n", ret);
    51. 			break;
    52. 		case 3:
    53. 			printf("请输入操作数：");
    54. 			scanf("%d%d", &x, &y);
    55. 			ret = Mul(x, y);
    56. 			printf("ret= %d\n", ret);
    57. 			break;
    58. 		case 4:
    59. 			printf("请输入操作数：");
    60. 			scanf("%d%d", &x, &y);
    61. 			ret = Div(x, y);
    62. 			printf("ret= %d\n", ret);
    63. 			break;
    64. 		case 0:
    65. 			printf("退出计算机\n");
    66. 			break;
    67. 		default:
    68. 			printf("选择错误，请重新选择\n");
    69. 			break;
    70. 		}
    71. 	} while (input);
    72.  
    73. 	return 0;
    74. }
    • 上面这段代码现在只具有加减乘除的功能，但是如果我想让它实现 a&&b、a||b、a&b、a|b、a>>b、a<
    • 那有没有什么办法让函数变得简洁呢，其实是有的。通过观察，会发现这些函数除了函数名和里边的计算不一样外，函数的参数都是两个int，返回类型都是int，所以我们可以通过函数指针数组来改写它。

    🌴使用函数指针数组的实现：

    1. void menu()
    2. {
    3. 	printf("************************\n");
    4. 	printf("***  1.Add    2.Sub  ***\n");
    5. 	printf("***  3.Mul    4.Div  ***\n");
    6. 	printf("***  0.exit          ***\n");
    7. 	printf("************************\n");
    8. }
    9.  
    10. int Add(int x, int y)
    11. {
    12. 	return x + y;
    13. }
    14. int Sub(int x, int y)
    15. {
    16. 	return x - y;
    17. }
    18. int Mul(int x, int y)
    19. {
    20. 	return x * y;
    21. }
    22. int Div(int x, int y)
    23. {
    24. 	return x / y;
    25. }
    26.  
    27. int main()
    28. {
    29. 	int input = 0;
    30. 	int x = 0;
    31. 	int y = 0;
    32. 	int ret = 0;
    33. 	do
    34. 	{
    35. 		menu();
    36. 		printf("请选择:> ");
    37. 		scanf("%d", &input);
    38. 		//函数指针数组 - 转移表
    39. 		int (*pfarr[5])(int, int) = { NULL,Add,Sub,Mul,Div };//放个NULL的原因是将这些操作函数的下标往右挤一位
    40. 	    if (0 == input)
    41. 		{
    42. 			printf("退出计算器\n");
    43. 		}
    44. 		else if (input >= 1 && input <= 4)
    45. 		{
    46. 			printf("请输入操作数:>");
    47. 			scanf("%d%d", &x, &y);
    48. 			ret = (pfarr[input])(x, y);
    49. 			printf("ret= %d\n", ret);
    50. 		}
    51. 		else
    52. 		{
    53. 			printf("选择错误，请重新选择！\n");
    54. 		}
    55. 	} while (input);
    56.  
    57. 	return 0;
    58. }

    四，指向函数指针数组的指针

    🎈我们先来看一下整型指针数组：

    1. int a = 10;
    2. int b = 20;
    3. int c = 30;
    4.  
    5. //整型指针数组，数组的每个元素是int*类型
    6. int* arr[] = { &a, &b, &c };
    7.  
    8. //p是指针，是指向整型指针数组的指针
    9. int* (*p)[3] = &arr;

    有了上面的例子我们再来看指向函数指针数组的指针：

    指向函数指针数组的指针是一个 指针
    指针指向一个 数组 ，数组的元素都是 函数指针

    1. void test(const char* str)
    2. {
    3. 	printf("%s\n", str);
    4. }
    5. int main()
    6. {
    7. 	//函数指针pfun
    8. 	void (*pfun)(const char*) = test;
    9.  
    10. 	//函数指针的数组pfunArr
    11. 	void (*pfunArr[5])(const char* str);
    12.  
    13. 	pfunArr[0] = test;
    14. 	//指向函数指针数组pfunArr的指针ppfunArr
    15. 	void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    16.  
    17. 	return 0;
    18. }
  • 相关阅读:
    4、命令式和声明式
    手写RPC框架-项目结构以及使用
    STL常用容器——deque容器的使用
    vue3组合式API实现父组件触发子组件中的方法 | vue3中ref的用法 | defineExpose的使用场景
    有向无权图的最短路径
    java实现调用百度地图
    十年沉浮，Web2 到 Web3 的转变之路
    各省、市转移支付数据集-分专项转移支付、一般转移支付、税收返还
    go语言grpc的快速体验-grpc流模式
    阿里二面凉了，难蹦。。。
  • 原文地址：https://blog.csdn.net/weixin_65931202/article/details/134272787