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

目录

​​ 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函数的多重功能。