指针进阶（2）-阿里云开发者社区

6.函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，

比如:

1. int *arr[10];
2. //数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

1. int (*parr1[10])();
2. int *parr2[10]();
3. int (*)() parr3[10];

答案是：parr1

parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。

如果我们想写一个加法函数，然后我们把这个函数的地址存放到pf1里面去，再写一个减法函数，将这个函数的地址存放到pf2里面去，但是我们如果写更多同类型的函数，都这样存放地址的话，就要重复这样的操作，所以我们可以创建一个函数指针数组，存放同类型函数指针。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int Add(int x, int y)
{
  return x + y;
}
int Sub(int x, int y)
{
  return x - y;
}
int main()
{
  //int (*pf1)(int,int) = &Add;
  //int (*pf2)(int,int) = &Sub;
    int (*pfarr[2])(int,int)={&Add,&Sub};
  return 0;
}

函数指针数组的用途：转移表.

例子：（计算器）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void menu()
{
  printf("********************************");
  printf("****1.Add   2.Sub***************");
  printf("****3.Mul   4.Div***************");
  printf("**** 0.exit  *******************");
}
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 (*pf)(int,int))
{
  int x = 0;
  int y = 0;
  int ret = 0;
  printf("请输入2个操作数:");
  scanf("%d %d", &x, &y);
  ret = pf(x, y);
  printf("ret = %d\n", ret);
}
int main()
{
  int input = 0;
    menu();
  printf("请选择:>");
  scanf("%d", &input);
  do
  {
    case 1:
      printf("请输入2个操作数:");
      scanf("%d %d", &x, &y);
      ret = Add(x, y);
      printf("ret = %d\n", ret);
      break;
    case 2:
      printf("请输入2个操作数:");
      scanf("%d %d", &x, &y);
      ret = Sub(x, y);
      printf("ret = %d\n", ret);
      break;
    case 3:
      printf("请输入2个操作数:");
      scanf("%d %d", &x, &y);
      ret = Mul(x, y);
      printf("ret = %d\n", ret);
      break;
        case 4:
      printf("请输入2个操作数:");
      scanf("%d %d", &x, &y);
      ret = Div(x, y);
      printf("ret = %d\n", ret);
      break;
      case 0:
      printf("退出计算器\n");
        break;
    default:      
            printf("选择错误, 重新选择\n");
      break;
    }
  } while (input);
  return 0;
}

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

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;
}
int main()
{
  int input = 0;
  int x = 0;
  int y = 0;
  int ret = 0;
  do
  {
    menu();
    printf("请选择:>");
    scanf("%d", &input);
    //函数指针数组 - 转移表
    int (*pfArr[])(int, int) = {NULL, Add, Sub, Mul, Div};
    //                          0     1     2   3    4
    if (0 == input)
    {
      printf("退出计算器\n");
    }
    else if (input >= 1 && input <= 4)
    {
      printf("请输入2个操作数:");
      scanf("%d %d", &x, &y);
      ret = pfArr[input](x, y);
      printf("ret = %d\n", ret);
    }
    else
    {
      printf("选择错误，重新选择!\n");
    }
  } while (input);
  return 0;
}

未来如果想要在这个功能的基础上加上其他的功能，先把菜单改变一下，再把该功能的代码写出来，再把这个函数的地址放在函数指针数组里面去就可以了，这样还不会增加switch的长度，这种写法非常的巧妙，但同时也是有缺陷的，有约束。就是这些函数的返回类型和参数必须都是int，必须保持一模一样。

7. 指向函数指针数组的指针

指向函数指针数组的指针是一个指针

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

如何定义？

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void test(const char* str)
{
  printf("%s\n", str);
}
int main()
{
  //函数指针pfun
  void (*pfun)(const char*) = test;
  //函数指针的数组pfunArr
  void (*pfunArr[5])(const char* str);
  pfunArr[0] = test;
  //指向函数指针数组pfunArr的指针ppfunArr
  void (*(*ppfunArr)[5])(const char*) = &pfunArr;
  return 0;
}

8. 回调函数

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

回调函数是一个非常重要的知识点，回调函数依赖函数指针，有了函数指针才能实现回调函数。

我们可以使用回调函数简化上面的计算器。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.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 (*pf)(int,int))
{
  int x = 0;
  int y = 0;
  int ret = 0;
  printf("请输入2个操作数:");
  scanf("%d %d", &x, &y);
  ret = pf(x, y);
  printf("ret = %d\n", ret);
}
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);
    break;
  case 0:
    printf("退出计算器\n");
    break;
  default:
    printf("选择错误, 重新选择\n");
    break;
  }
  } while (input);
  return 0;
}

通过回调函数可以使得函数变得通用，拥有多种功能。

首先演示一下qsort函数的使用：

qsort是一个库函数，底层使用的是快速排序的方式，对数据进行排序的。这个函数可以直接使用，可以用来排序任意类型的数据。

首先我们来回忆一下冒泡排序，冒泡排序的核心思想就是相邻的两个元素进行比较。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void print_arr(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
  printf("\n");
}
void bubble_sort(int arr[], int sz)
{
  //趟数
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
  //每一趟冒泡排序的过程
  int j = 0;
  for (j = 0; j < sz - 1 - i; j++)
  {
    if (arr[j] > arr[j + 1])
    {
    int tmp = arr[j];
    arr[j] = arr[j + 1];
    arr[j + 1] = tmp;
    }
  }
  }
}
int main()
{
  //数据
  int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  print_arr(arr, sz);
  bubble_sort(arr, sz);//冒泡排序
  print_arr(arr, sz);
  return 0;
}

这个函数有个不好的地方就是只能排序整型数组，所以并不通用，但是qsort函数可以排序任意类型的数据。

void qsort(void* base, //待排序数组的第一个元素的地址
           size_t num, //待排序数组的元素个数
         size_t size,//待排序数组中一个元素的大小
         int (* cmp)(const void* e1, const void* e2)//函数指针-cmp指向了一个函数，这个函数是用来比较两个元素的
         //e1和e2中存放的是需要比较的两个元素的地址
          );

如果我们需要排序整型数组的话，我们就要自己写一个比较函数。

void* 类型的指针 - 不能进行解引用操作符，也不能进行+-整数的操作。

void* 类型的指针是用来存放任意类型数据的地址。

void* 无具体类型的指针。

写成void*指针的好处是在进行调用这个函数的时候可以根据自己的需求进行转换。

所以我们需要将e1和e2进行强制类型转换成int*，将他们做差，将结果返回。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
  return *(int*)e1 - *(int*)e2;
}
void print_arr(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
  printf("\n");
}
//测试qsort排序整型数据
void test1()
{
  int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  print_arr(arr, sz);
  qsort(arr, sz, sizeof(arr[0]), cmp_int);
  print_arr(arr, sz);
}
int main()
{
  //数据
  test1();
  //test2();
  //test3();
  return 0;
}

如果我们想排序结构体数组，那我们就写一个test2和test3，test2比较年龄，test3比较名字。

所以这里我们要重新写一个比较函数，比较名字的话我们就先强制类型转换成struct Stu*，然后用->来访问，再进行作差。

test3也需要写一个比较函数，所以我们也强制类型转换成struct Stu*，再用strcmp来比较，strcmp的返回值刚好是0，>0或者<0。

struct Stu
{
  char name[20];
  int age;
};
//结构体数据怎么比较呢？
//1. 按照年龄比较
//2. 按照名字比较
int cmp_stu_by_age(const void* e1, const void* e2)
{
  return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test2()
{
  struct Stu arr[] = { {"zhanhsan", 20}, {"lisi", 30}, {"wangwu", 12} };
  int sz = sizeof(arr) / sizeof(arr[0]);
  qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
  return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test3()
{
  struct Stu arr[] = { {"zhanhsan", 20}, {"lisi", 30}, {"wangwu", 12} };
  int sz = sizeof(arr) / sizeof(arr[0]);
  qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

指针进阶（2）

6.函数指针数组

7. 指向函数指针数组的指针

8. 回调函数

热门文章

最新文章

相关课程

相关电子书