【进阶指针二】数组传参&指针传参&函数指针&函数指针数组&回调函数

【进阶指针一】字符指针&指针数组&数组指针https://blog.csdn.net/qq_64428099/article/details/125011487

目录

 1.数组传参

1-2 二维数组传参 

2 指针传参

2-1 一级指针传参

2-2 二级指针传参

2-3 关于传&arr和arr

3 函数指针

3-1 函数指针的引入

3-2 函数指针的脱裤子放屁使用【先见一见基本操作】

3-3 试图看懂大佬写的代码

 4 函数指针数组

4-1函数指针数组的引入和基本使用

 4-2 函数指针数组的妙用

---

 1.数组传参

1-1一维数组传参

正向：实参给定，猜猜看形参可以怎么写？

测试1：

注:这里没有要求打印，所以没有传元素个数sz

 测试2：

void test2(int* arr2[10])//bingo
void test2(int* arr2[])//bingo
void test2(int** arr2)//bingo

int main()
{
	int* arr2[10] = { 0 };
	test2(arr2);//数组名是首元素(int*类型)的地址
	return 0;
}

1-2 二维数组传参 

void test(int arr[3][5])//bingo-列必须写上，且必须写对
void test(int arr[][5])//bingo -敲黑板！！！行可以省略，但是列不可以省略
void test(int arr[][])//error -列必须写上，且必须写对

void test(int(*p)[5])//bingo -数组指针，指针指向的是一个一维数组



int main()
{
	int arr[3][5] = { 0 };
	test(arr);//数组名是首元素(int [5]类型)的地址
	return 0;
}

关于我对二维数组及多维数组的理解： 

 由二维数组引申的两个普遍规律：

1. 我们所知的复合类型（比如数组，结构体等）的类型名都是首元素的地址（两个特殊情况除外）。

2. 对于多维数组定义或者传参时，只有第一维数组的数组元素可以省略，其余维必须写上，且必须写对！！！

2 指针传参

反向：形参给定，猜猜看实参可以怎么写？

2-1 一级指针传参

void test1(int* ptr)//一级指针:存放普通变量的地址
{
	//...
}

int main()
{
	int a = 10;
	int* p = &a;

	test1(&a);
	test1(p);//p是一级指针变量的内容

	int arr[10];
	test1(arr);

	return 0;
}

2-2 二级指针传参

void test2(int** pp)//二级指针:存放一级指针的地址
{
	//...
}

int main()
{
	char ch = 'a';
	char* pch = &ch;
	char** ppch = &pch;
	
	test2(&pch);
	test2(ppch);

    //错误范例1：
    test2(&&ch);ch的地址（数据）是没有地址的，只有ch的地址被变量存起来（变量）才有地址

	char* arr[5];
	test2(arr);//数组名是首元素（也就是一级指针变量）的地址


    //错误范例2：
    char arr2[3][5];
    test2(arr);//error!!!!// arr是二维数组数组名，表示的是一维数组的地址
   
	return 0;
}

2-3 关于传&arr和arr

2-3-1 这里以二维数组为例，讲一讲实参和形参的匹配问题

void test1(int(*p)[5])// int[5]*类型
{
	;
}

void test2(int(*p)[3][5]) //int[3][5]*类型
{
	;
}

int main()
{
	int arr[3][5];
	test1(arr);//二维数组首元素（整个一维数组）的地址
	test2(&arr);//整个二维数组的地址
	return 0;
}

这里以一维数组为例，讲一讲函数内要想打印的具体实现（&arr的鸡肋问题）：

如果在主函数调用的时候传&arr的话就太鸡肋了！（因为你传整个数组的地址，你又不能一次性打印出来，你还得对整个数组的地址进行解引用。

解引用后就是一维数组的数组名，因为这个数组名不是那两个特殊情况，所以这个数组名又摇身一变，变成数组首元素的地址，到这里就和直接在主函数调用的时候传arr的效果是一样的）

void Print1(int* arr,int n)
{
	printf("Print1:>\n");
	for (int i = 0; i < n; i++)
	{
		printf("arr[%d]=%d\t", i, *(arr + i));
	}
}

void Print2(int(*arr)[3], int n)
{
	printf("Print2:>\n");
	for (int i = 0; i < n; i++)
	{
		printf("arr[%d]=%d\t", i, *(*arr + i));//鸡肋
	}
}

int main()
{
	int arr[3] = { 1,2,3 };

	Print1(arr,3);
	printf("\n\n");
	Print2(&arr,3);
	return 0;
}

 

3 函数指针

函数是放在代码区的，只要是定义了就会在编译阶段就会分配空间，和全局变量一样。

3-1 函数指针的引入

int Add(int a, int b)
{
	return a + b;
}



int main()
{
	//函数也有地址
	printf("%p\n", Add);
	printf("%p\n", &Add);//-取地址只是摆设捏

	//有地址能不能用能不能用指针变量存起来-函数指针

	int (*p1)[3];//-数组指针
	int(*p2)(int,int) = &Add;//-函数指针,指向函数的指针
	printf("%p\n", p2);

	return 0;
}

[]和()的运算符优先级都比*高 

 

关于为什么要有函数参数的一点思考：

-这和数组指针类似,int(*p)[5],这个[5]是对指针指向的内容的必要说明，也就是所指向数组类型的一部分，不可省略。

-同理，函数指针的类型里的返回值和形参都是对所指向函数的必要说明。

    char* test(int(*p)[5], char*)
    {
	  return NULL;
    }

	//问题：来照猫画虎写一个指向这个函数的函数指针
	//答案：char*(*p)(int(*)[5], char*) = &test;

3-2 函数指针的脱裤子放屁使用【先见一见基本操作】

int Add(int a, int b)
{
	return a + b;
}


int main()
{
	printf("test1:\n%p\n", &Add);
	printf("test2:\n%p\n", Add);

	int(*p)(int, int) = &Add;
	//int(*p)(int, int) = Add;
	
	printf("test3:\n%d\n", Add(2, 3));
	printf("test4:\n%d\n", (*p)(2,3));
	printf("test5:\n%d\n", p(2,3));
	//在获得函数地址时，&和不加&都可以，但是加上&更好理解
	//在通过调用函数时, *和不加*都可以，但是加上*更好理解，且必须要带上括号

	return 0;
}

3-3 试图看懂大佬写的代码

代码1:

(*(void(*)())();
//提示：这个整体是函数调用

 子例程：函数

参考：《C陷阱和缺陷》

 

 代码2：

void(* signal(int,void(*)())(int);
//提示：这个整体是函数声明

小小勘误:图片中第3步中指针类型应该改为函数指针类型 

 4 函数指针数组

4-1函数指针数组的引入和基本使用

只要你前面学会了，这里就是一样的套用，我这里就不啰嗦了

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()
{
	//字符指针数组
	char* arr1[5];
	//整型指针数组
	int* arr2[5];

	//函数指针数组
	//int(*pf[4])(int, int);

	//在没有函数指针数组之前...
	int(*pf1)(int, int) = Add;
	int(*pf2)(int, int) = Sub;
	int(*pf3)(int, int) = Mul;
	int(*pf4)(int, int) = Div;

	//有函数指针数组之后...
	int(*pf[4])(int, int) = { Add,Sub,Mul,Div };
	for (int i = 0; i < 4; i++)
	{
		int ret=pf[i](6, 2);
		printf("%d\n", ret);
	}

	return 0;
}

 函数指针数组的优缺点：

- 优点：不用一个一个定义变量去存储函数的地址，然后一个一个去调用

- 缺点：函数指针数组既然是数组，就要求是相同类型元素的集合，也就是返回值和参数类型的一样才能放到函数指针数组内，统一进行操作。

 4-2 函数指针数组的妙用

函数指针数组实现加减乘除运算器，这里的函数指针数组被称为转移表

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 1.0*a / b;
}

void meau(void)
{
	printf("**************************\n");
	printf("******     1.Add     *****\n");
	printf("******     2.Sub     *****\n");
	printf("******     3.Mul     *****\n");
	printf("******     4.Div     *****\n");
	printf("******     0.exit    *****\n");
	printf("**************************\n");
}

int main()
{
	int input = 0;
	int operand1 = 0;
	int operand2 = 0;
	int(*pf[5])(int, int) = {0,Add,Sub,Mul,Div};
	meau();
	do
	{
		printf("请输入你的选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出程序\n");
			break;
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:>");
			scanf("%d%d", &operand1, &operand2);
			printf("%d\n", pf[input](operand1,operand2));
		}
		else
		{
			printf("输入非法，请重新输入\n");
			continue;
		}

	} while (input);
	return 0;
}

5 回调函数

回调函数：把函数1的地址作为函数2的函数参数，从而调用函数2，然后再函数2实现过程中通过指针调用函数1，那么这个被其他函数调用的函数（函数1）就被称为回调函数。

void test1(void(*p)())
{
	(*p)();
}

void test2()
{
	printf("test2\n");
}
int main()
{
	test1(&test2);
}

5-1 回调函数的使用举例1：计算器

原来的switch  case 语句好多冗余的语句，又有前提减加乘除的函数参数和返回值类型相同，所以可以使用回调函数处理这个问题。

void cal(int (*p)(int, int))
{
	int o1 = 0;
	int o2 = 0;
	printf("请输入两个操作数:>");
	scanf("%d%d", &o1, &o2);
	printf("%d\n", p(o1, o2));
}

int main()
{
	int input = 0;

	meau();
	do
	{
		printf("请输入你的选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			cal(Add);
			break;

		case 2:
			cal(Sub);
			break;

		case 3:
			cal(Mul);
			break;

		case 4:
			cal(Div);
			break;

		case 0:
			printf("exit\n");
			break;

		default:
			printf("非法\n");
		}

	} while (input);
	return 0;
}

这里的Add,Sub,Mul,Div函数都是回调函数，通过传不同函数的地址给Cal函数,Cal函数内部用函数指针接收，从而实现了Cal函数的多重功能。