【C语言进阶】指针进阶（干货）

目录

一、字符指针

二、指针数组

三、数组指针

                1、数组指针的定义

                2、&数组名和数组名的区别

                3、数组指针的使用

四、数组传参和指针传参 

                1、一维数组传参

                2、一级指针传参

                3、二维数组传参

                4、二级指针传参

五、函数指针

                1、函数指针的定义

                2、函数指针的使用

六、函数指针数组

                1、函数指针数组的定义

                2、函数指针数组的用途

七、指向函数指针数组的指针

                1、定义

八、回调函数

九、总结

---

一、字符指针

字符变量的地址用字符指针接收

  

   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      char ch = 
      'x';
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      //ptr前的*是在告诉我们ptr是指针
     
    
   

    

     

    
    

     
	
      char* ptr = &ch;
      //字符变量的地址用字符指针ptr接收
     
    
   

    

     

    
    

     

      }
     
    
  

还有另外一种使用方式

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
    
      //常量字符串不能被修改，用const修饰
     
    
   

    

     

    
    

     
	
      const 
      char* ptr = 
      "happy new year";
     
    
   

    

     

    
    

     
	
      printf(
      "%s\n", ptr);
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

这串代码很容易认为是把字符串"happy new year"放到字符指针ptr里了，但本质是把字符串“happy new year”的首字母h的地址放到了ptr中。

剑指offer例题

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      char a[] = 
      "hello";
     
    
   

    

     

    
    

     
	
      char b[] = 
      "hello";
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      const 
      char* c = 
      "hello";
     
    
   

    

     

    
    

     
	
      const 
      char* d = 
      "hello";
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      if (a == b)
     
    
   

    

     

    
    

     
		
      printf(
      "a和b相同\n");
     
    
   

    

     

    
    

     
	
      else
     
    
   

    

     

    
    

     
		
      printf(
      "a和b不相同\n");
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      if (c == d)
     
    
   

    

     

    
    

     
		
      printf(
      "c和d相同\n");
     
    
   

    

     

    
    

     
	
      else
     
    
   

    

     

    
    

     
		
      printf(
      "c和d不同\n");
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

【程序运行结果】

为什么是以上的结果呢？

 不同的数组在创建时，会在内存中开辟不同的空间。由于地址不同，则a和b不相同。

因为常量字符串永远都不会被改变掉，所以它在内存中就没必要再开辟一个空间来存放另一个hello，所以c和d会同时指向字符串的首地址。

二、指针数组

  

   

    

     

    
    

     

      int* arr[
      10];
     
    
   

    

     

    
    

     

      char* arr[
      10];
     
    
  

指针数组本质上就是数组，是一个存放指针的数组(或存放地址的数组)

详细内容请看《初阶指针》  点击跳转

三、数组指针

1、数组指针的定义

数组指针本质上是指针，是能够指向数组的指针。

  

   

    

     

    
    

     

      int *p[
      10];
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      解释：
     
    
   

    

     

    
    

     

      优先级 * < [],所以p指向的是数组，并且每一个元素的类型都是
      int*，
     
    
   

    

     

    
    

     

      所以它是一个指针数组
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int (*p)[
      10];
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      解释：
     
    
   

    

     

    
    

     

      由于加了括号，p先和*结合，这说明了p是一个指针，然后指向一个大小
     
    
   

    

     

    
    

     

      为
      10的数组，并且每一个元素都是
      int类型，所以它是一个数组指针
     
    
  

2、&数组名和数组名的区别

这块内容在《深入学习数组》已经讲过了  点击跳转

这里再为大家说说它们的区别

对于下面的数组

int arr[10];

我们都知道arr是数组名，数组名表示数组首元素的地址。

那&arr是什么意思，我们分别打印出它们的地址

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int arr[
      10] = { 
      0 };
     
    
   

    

     

    
    

     
	
      printf(
      "arr：%p\n", arr);
     
    
   

    

     

    
    

     
	
      printf(
      "&arr:%p\n", &arr);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

【程序运行结果】

 可见它们的地址都是一样的，难道它们真的是一样的吗？我们再来看一段代码

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int arr[
      10] = { 
      0 };
     
    
   

    

     

    
    

     
	
      printf(
      "arr：%p\n", arr);
     
    
   

    

     

    
    

     
	
      printf(
      "arr：%p\n", arr + 
      1);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      printf(
      "&arr:%p\n", &arr);
     
    
   

    

     

    
    

     
	
      printf(
      "&arr:%p\n", &arr + 
      1);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

 【程序运行结果】

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义却不一样。

实际上：&arr是的是数组的地址(整个数组)，而不是数组首元素的地址。&arr + 1，跳过的是整个数组的大小。

&arr的类型是,是一种数组指针类型

3、数组指针的使用

一般用于二维数组

例：用一个数组指针打印一个二维数组

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      //二维数组传参arr[][3]、arr[3][3]
     
    
   

    

     

    
    

     

      void Print(int(*p)[3], int row, int col) //二维数组arr是第一行数组的地址，
     
    
   

    

     

    
    

     
                                         
      //也就是一个一维数组的地址
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      for (
      int i = 
      0; i < row; i++)
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
		
      for (
      int j = 
      0; j < col; j++)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			
      printf(
      "%d ", p[i][j]);
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
      printf(
      "\n");
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

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

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
      //封装一个数组来打印
     
    
   

    

     

    
    

     
	
      Print(arr, 
      3, 
      3);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

 【程序运行结果】

 最后再看看下面这几行代码的意思

  

   

    

     

    
    

     

      int arr[
      5];  
      //整型数组，数组有5个元素
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int* p[
      10];  
      //是指针数组，数组有10个元素，每个元素的类型是int*
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int(*p)[
      10]; 
      //数组指针，指向10个元素的数组，每个元素是int类型
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int(*p[
      10])[
      5]; 
      //这个要拆开看，p先和[]结合，是一个数组有5个元素，
     
    
   

    

     

    
    

     
				
      //并且它的类型是int(*)[5] (把p[10]去掉就是其类型)
     
    
  

四、数组传参和指针传参 

 在写代码的时候难免要把【函数】或者【指针】传给数组，那函数的参数改如何设计呢？一起来看吧

1、一维数组传参

  

   

    

     

    
    

     

      //一维数组传参的形参可以这么写
     
    
   

    

     

    
    

     

      void test(int arr[])
     
    
   

    

     

    
    

     

      void 
      test
      (int arr[10])
     
    
   

    

     

    
    

     

      void 
      test
      (int* arr) 
      //arr是数组首元素的地址，用指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int 
      main
      ()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int arr[
      10] = { 
      0 };
     
    
   

    

     

    
    

     
	
      //函数传参传参
     
    
   

    

     

    
    

     
	
      test(arr);
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

2、一级指针传参

  

   

    

     

    
    

     

      //一级指针传参
     
    
   

    

     

    
    

     

      void test(int *arr[10])//一级指针接收，大小也可省略不写
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      void 
      test
      (int **arr) 
      //arr是首元素地址，数组每一个元素类型都是int*
     
    
   

    

     

    
    

     
					 
      //一级指针传参可以拿二级指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int 
      main
      ()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int* arr[
      10] = { 
      0 };
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      test(arr);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

3、二维数组传参

  

   

    

     

    
    

     

      void test(int arr[3][3])
     
    
   

    

     

    
    

     

      void 
      test
      (int arr[][4])
      //行可省，列不可省
     
    
   

    

     

    
    

     

      void 
      test
      (int (*p)[3]) 
      //二维数组arr是第一行的地址
     
    
   

    

     

    
    

     
					   
      //第一行的地址就是整个一维数组的地址，所以用数组指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int 
      main
      ()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int arr[
      3][
      3] = { 
      0 };
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      test(arr);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

4、二级指针传参

思考：函数的参数为二级指针，实参可以是什么？？

  

   

    

     

    
    

     

      void test(int** p)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     

      	;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int** p;
     
    
   

    

     

    
    

     
	
      test(p);
      //二级指针传参，二级指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      int* p;
     
    
   

    

     

    
    

     
	
      test(&p);
      //一级指针地址传参，二级指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      int* arr[
      10];
     
    
   

    

     

    
    

     
	
      test(arr);
      //arr作为首元素地址，每个元素都是int*类型，二级指针接收
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

五、函数指针

1、函数指针的定义

函数指针的本质上也是个指针，它是指向函数的指针。

这可以类比数组指针（指向数组的指针）

  

   

    

     

    
    

     

      int arr[
      10];
     
    
   

    

     

    
    

     

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

我们也能不能&函数名，拿到函数的地址呢？然后再把函数的地址存到一个函数指针变量里呢？

来看看下面的一段代码

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int Add(int x, int y)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      return x + y;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      printf(
      "%p", &Add);
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

【程序结果】

通过以上代码我们发现，函数名也是有地址的，所以我们能不能创建一个变量并把这个地址存起来呢？

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int Add(int x, int y)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      return x + y;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int (*p)(
      int, 
      int) = &Add;
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

接下来还能类比，&arr不加&，arr则是数组首元素的地址，如果不&数组名，那么单独的数组名是否是函数首元素的地址呢？

让我们用代码说话 

总结：&数组名和数组名都是函数的地址。 

2、函数指针的使用

既然p指向Add函数，所以能不能用p来调用Add函数呢？

这时就得用到解引用操作符

不能口说无凭，咱代码说话

  

   

    

     

    
    

     

      #include <stdio.h>
     
    
   

    

     

    
    

     

      int Add(int x, int y)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      return x + y;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int (*p)(
      int, 
      int) = &Add;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
      //对指针p解引用找到Add函数
     
    
   

    

     

    
    

     
	
      int res = (*p)(
      100, 
      200);
     
    
   

    

     

    
    

     
	
      printf(
      "%d\n", res);
     
    
   

    

     

    
    

     
	
      return 
      0;
     
    
   

    

     

    
    

     

      }
     
    
  

【程序运行结果】

 这样一串下来，我们就发现一段关系

*p == Add == &Add == p

所以上述的代码中，解引用操作符就可以去掉了

六、函数指针数组

1、函数指针数组的定义

函数指针数组本质上是一个数组，是用来存放函数地址的数组。

  

   

    

     

    
    

     

      类比一下：
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      指针数组
     
    
   

    

     

    
    

     

      //存放的是字符指针
     
    
   

    

     

    
    

     

      char* arr[
      10];
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      //存放整型指针
     
    
   

    

     

    
    

     

      int* arr[
      10];
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      //那么函数指针就是存放 函数指针的数组
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      例如：
     
    
   

    

     

    
    

     

      int Add(int x,int y)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
    
      return x + y;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
   
      int (*p)(
      int,
      int) = &Add 
      //函数指针
     
    
   

    

     

    
    

     
      
     
    
   

    

     

    
    

     
    
      //函数指针数组就是基于函数指针改造的
     
    
   

    

     

    
    

     
    
      //函数指针数组本质上是个数组
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      int (*p[
      3])(
      int,
      int) = {&Add};
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      //[]的优先级高于*,所以p先和[]结合，所以p是个数组
     
    
   

    

     

    
    

     
    
      //类型是 int (*)(int,int) -->函数指针类型
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

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 menu()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 1.Add 2.Sub ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 3.Mul 4.Div ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "***** 0.Exit ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int input = 
      0;
     
    
   

    

     

    
    

     
	
      int x = 
      0;
     
    
   

    

     

    
    

     
	
      int y = 
      0;
     
    
   

    

     

    
    

     
	
      int res = 
      0;
     
    
   

    

     

    
    

     
	
      do
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
		
      menu(); 
      //打印菜单
     
    
   

    

     

    
    

     
		
      printf(
      "请选择：");
     
    
   

    

     

    
    

     
		
      scanf(
      "%d", &input);
     
    
   

    

     

    
    

     
		
      switch (input)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
		
      case 
      1:
     
    
   

    

     

    
    

     
			
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
			
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     

      			res = 
      Add(x, y);
     
    
   

    

     

    
    

     
			
      printf(
      "相加的结果为：%d\n", res);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
      case 
      2:
     
    
   

    

     

    
    

     
			
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
			
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     

      			res = 
      Sub(x, y);
     
    
   

    

     

    
    

     
			
      printf(
      "相减的结果为：%d\n", res);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
      case 
      3:
     
    
   

    

     

    
    

     
			
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
			
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     

      			res = 
      Mul(x, y);
     
    
   

    

     

    
    

     
			
      printf(
      "相乘的结果为：%d\n", res);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
      case 
      4:
     
    
   

    

     

    
    

     
			
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
			
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     

      			res = 
      Div(x, y);
     
    
   

    

     

    
    

     
			
      printf(
      "相除的结果为：%d\n", res);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
      case 
      0:
     
    
   

    

     

    
    

     
			
      printf(
      "退出计算器");
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
      default:
     
    
   

    

     

    
    

     
			
      printf(
      "选择错误\n");
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	} 
      while (input);
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

【程序运行结果】

若此时计算器中还要加入按位与&、按位或|等操作符运算，虽然只要在代码内部多加几行函数，但这也会导致代码越来越来长。所以，可以使用函数指针数组来分别存放Add、Sub的地址

【代码实现】

  

   

    

     

    
    

     

      #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 menu()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 1.Add 2.Sub ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 3.Mul 4.Div ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "***** 0.Exit ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      //函数指针数组
     
    
   

    

     

    
    

     

      int (*p[
      5])(
      int, 
      int) = { 
      0,Add,Sub,Mul,Div };
     
    
   

    

     

    
    

     

      //这里的0，是为了和菜单对应，当然也可以写NULL
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int input = 
      0;
     
    
   

    

     

    
    

     
	
      int x = 
      0;
     
    
   

    

     

    
    

     
	
      int y = 
      0;
     
    
   

    

     

    
    

     
	
      int res = 
      0;
     
    
   

    

     

    
    

     
	
      do
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
		
      menu(); 
      //打印菜单
     
    
   

    

     

    
    

     
		
      printf(
      "请选择：");
     
    
   

    

     

    
    

     
		
      scanf(
      "%d", &input);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      if (input == 
      0)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			
      printf(
      "退出计算器\n");
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
      else 
      if (input >= 
      1 && input <= 
      4)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
			
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
			
      //当input为0则退出,
     
    
   

    

     

    
    

     
			
      //当input为1则调用Add函数
     
    
   

    

     

    
    

     
			
      //以此类推...
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
			
      int res = p[input](x, y);
     
    
   

    

     

    
    

     
			
      printf(
      "结果为：%d\n", res);
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
      else
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			
      printf(
      "选择错误，请重新选择\n");
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	} 
      while (input);
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

【程序运行结果】

七、指向函数指针数组的指针

指向函数指针数组的指针本质上是个指针

指针指向一个数组

数组每个元素的类型都是函数指针

 1、定义

  

   

    

     

    
    

     

      int Add(int x, int y)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      return x + y;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      //整型数组
     
    
   

    

     

    
    

     
	
      //arr是数组，&arr
     
    
   

    

     

    
    

     
	
      int arr[
      10] = { 
      0 };
     
    
   

    

     

    
    

     
	
      int(*p)[
      10] = &arr; 
      //数组指针
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
      //函数指针数组
     
    
   

    

     

    
    

     
	
      //同样的，p也是个数组，也&p
     
    
   

    

     

    
    

     
	
      int (*p[
      3])(
      int, 
      int);
     
    
   

    

     

    
    

     
	
      int (*(*pp)[
      3])(
      int, 
      int) = &p; 
      //这就是指向函数指针数组的指针
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

用概念再来分析一下

int (*(*pp)[3])(int, int) = &p

①pp先和*结合，说明pp是一个指针

②指向一个数组有3个元素

③每个元素的类型都是int (*)(int, int) --> 函数指针类型

Q：这么复杂类型怎么看？

int (*(*pp)[3])(int, int)，把(*pp)[3]去掉，剩下就是类型

八、回调函数

回调函数就是一个通过函数指针调用的函数。

就像上面的代码，方框部分是有大部分代码是重复的，我们可以利用回调函数的方式来把它变得更加简洁

【代码实现】

  

   

    

     

    
    

     

      #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 calc(int (*p)(int ,int)) //函数传参，函数指针接收
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int x = 
      0;
     
    
   

    

     

    
    

     
	
      int y = 
      0;
     
    
   

    

     

    
    

     
	
      printf(
      "请输入两个整数：");
     
    
   

    

     

    
    

     
	
      scanf(
      "%d %d", &x, &y);
     
    
   

    

     

    
    

     
	
      int res = 
      p(x, y);
     
    
   

    

     

    
    

     
	
      printf(
      "计算结果为：%d\n",res);
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      void menu()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 1.Add 2.Sub ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "**** 3.Mul 4.Div ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "***** 0.Exit ****\n");
     
    
   

    

     

    
    

     
	
      printf(
      "*******************************\n");
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	
      int input = 
      0;
     
    
   

    

     

    
    

     
	
      do
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
		
      menu(); 
      //打印菜单
     
    
   

    

     

    
    

     
		
      printf(
      "请选择：");
     
    
   

    

     

    
    

     
		
      scanf(
      "%d", &input);
     
    
   

    

     

    
    

     
		
      switch (input)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
		
      case 
      1:
     
    
   

    

     

    
    

     
			
      calc(Add);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      case 
      2:
     
    
   

    

     

    
    

     
			
      calc(Sub);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      case 
      3:
     
    
   

    

     

    
    

     
			
      calc(Mul);
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      case 
      4:
     
    
   

    

     

    
    

     
			
      calc(Div);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      case 
      0:
     
    
   

    

     

    
    

     
			
      printf(
      "退出计算器");
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
		
      default:
     
    
   

    

     

    
    

     
			
      printf(
      "选择错误\n");
     
    
   

    

     

    
    

     
			
      break;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	} 
      while (input);
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

 九、总结

本章重点讲解了数组指针、数组传参、指针传参、函数指针、回调函数和函数指针数组等内容。欲知后事如何，关注博主，下期更精彩！！

转载：https://blog.csdn.net/Weraphael/article/details/128746579