指针从入门到精通（三）

一、 数组指针变量

1.1  数组指针变量是什么？

之前我们学习了指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。

数组指针变量是指针变量？还是数组？

答案是：指针变量。

我们已经熟悉：

（1） 整形指针变量： int * p; 存放的是整形变量的地址，能够指向整形数据的指针。

（2） 字符指针变量： char * p; 存放字符变量的地址，能够指向字符数据的指针。

那数组指针变量应该是：存放的是数组的地址，能够指向数组的指针变量。

数组指针变量是什么样的呢？

int (*p)[10];

解释：p先和*结合，说明p是⼀个指针变量变量，然后指着指向的是⼀个大小为10个整型的数组。所以 p是⼀个指针，指向⼀个数组，叫数组指针。 这里要注意：[  ]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

1.2 数组指针变量怎么初始化

数组指针变量是⽤来存放数组地址的，那怎么获得数组的地址呢？

就是我们之前学习的 & 数组名 。

#include <stdio.h>
int main()
{
  int arr1[10];
  int(*p)[10] = &arr1;
  char* arr2[10];
  char* (*arr2)[10]=&arr2;
  return 0;
}

数组指针类型解析：

根据上面代码，arr1数组首元素地址的指针类型为int *;&arr1数组地址的指针类型为

int（*）[10];&arr2字符指针数组地址的指针类型char* (*)[10]。

指针类型决定+1,跳过的字节是多少。

arr1+1跳过一个int类型字节；

&arr1+1跳过int [10]类型字节。

二、二维数组传参的本质

有了数组指针的理解，我们就能够讲⼀下⼆维数组传参的本质了。

过去我们有⼀个⼆维数组需要传参给⼀个函数的时候，我们是这样写的：

#include <stdio.h>
void test(int a[3][5], int r, int c)
{
  int i = 0;
  int j = 0;
  for (i = 0; i < r; i++)
  {
  for (j = 0; j < c; j++)
  {
    printf("%d ", a[i][j]);
  }
  printf("\n");
  }
}
int main()
{
  int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
  test(arr, 3, 5);
  return 0;
}

这⾥实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？

首先我们再次理解⼀下⼆维数组，⼆维数组起始可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的首元素就是第一行，是个⼀维数组。

如下图：

所以，根据数组名是数组首元素的地址这个规则，⼆维数组的数组名表示的就是第一行的地址，是⼀ 维数组的地址。根据上⾯的例⼦，第⼀⾏的⼀维数组的类型就是 int [5] ，所以第⼀⾏一维数组的指针类型就是数组指针类型 int(*)[5] 。那就意味着 ⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址，那么形参也是可以写成指针形式 的。如下：

void test(int (*p)[5], int r, int c)；

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式。

三、函数指针变量

3.1  函数指针变量的创建

什么是函数指针变量呢？

根据前⾯学习整型指针，数组指针的时候，我们的类⽐关系，我们不难得出结论：

函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

那么函数是否有地址呢？

#include <stdio.h>
void test()
{
  printf("hehe\n");
}
int main()
{
  printf("test: %p\n", test);
  printf("&test: %p\n", &test);
  return 0;
}

输出结果：

确实打印出来了地址，所以函数是有地址的，函数名就是函数的地址，当然也可以通过 & 函数名 的⽅式获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量，函数指针变量的写法其实和数组指针

⾮常类似。如下：

#include <stdio.h>
int Add(int x, int y)
{
 return x+y;
}
int main()
{
  int(*pf3)(int, int) = Add;
    int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的
  return 0;
}

函数指针类型解析：

3.2 函数指针的调用

#include <stdio.h>
int Add(int x, int y)
{
  return x + y;
}
int main()
{
  int(*pf3)(int, int) = Add;
  printf("%d\n", (*pf3)(2, 3));
  printf("%d\n", pf3(2, 3));
  return 0;
}

函数指针的调用可以有* (*pf3)(2, 3)，也可以没*pf3(2, 3) ；这俩种调用都正确。

学习到这里，我们来看下下面的代码：

代码1

(*(void (*)())0)();

解析： (*(void (*)())0)()中红色部分为函数指针类型，外面加括号表示将0强制类型转换成函数地址，意思是在地址为0处有一个void ()的函数；还剩（*  ）（）表示检应用这个函数。这句代码意思是调用0地址处函数，该函数返回类型为void,函数无参。

代码2

void (*signal(int , void(*)(int)))(int);

解析：void (*signal(int , void(*)(int)))(int)中的红色部分为函数指针类型，

void (*signal(int , void(*)(int)))(int)绿色部分为函数声明，声明的signal的一个参数是int,另一个参数是函数指针类型;剩下的部分为void(*)(int),这个为函数指针类型，表示signal函数的返回类型为void(*)(int)函数指针类型。可以理解为void (*)(int)   signal(int , void(*)(int))，不过这样写是错误的。

3.3 重命名

上面的函数类型比较复杂，有什么办法可以简单化吗？

这就要学习typedef关键字 ，typedef 是⽤来类型重命名的，可以将复杂的类型，简单化。

你觉得 unsigned int 写起来不⽅便，如果能写成 uint 就⽅便多了，那么我们可以使⽤：

typedef unsigned int uint;//将unsigned int 重命名为uint

如果是指针类型，能否重命名呢？其实也是可以的，⽐如，将 int* 重命名为 ptr_t ,这样写：

typedef int* ptr_t;

但是对于数组指针和函数指针稍微有点区别：

比如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

typedef int(*parr_t)[5]; //新的类型名必须在*的右边

函数指针类型的重命名也是⼀样的，⽐如，将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

typedef void(*pfun_t)(int);//新的类型名必须在*的右边

那么要简化代码2，可以这样写：

1. typedef void(*pf_t)(int);
2. pf_t signal(int, pf_t);

这样写的优势，这样的代码的可读性比较好。

四、函数指针数组

整型指针数组：数组，数组中存放的都是整型变量的地址；

函数指针数组：数组，数组中存放的都是函数地址。

那函数指针的数组如何定义呢？

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

答案是：parr1

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

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

函数指针数组解析图：

五、函数指针的用途

函数指针数组的⽤途：转移表

比如使用函数指针数组实现计算器：

//实现计算器
#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 meun()
{
  printf("*****1.add   2.sub********\n");
  printf("*****3.mul   4.div********\n");
  printf("********** 0.exit ********\n");
}
int main()
{
  int a = 0;
  int b = 0;
  int i = 0;
  int ret = 0;
  int (*p[])(int, int) = { 0,add,sub,mul,div };//转移表
  do
  {
  meun();
  printf("请选择：");
  scanf("%d", &i);
  if (i >= 1 && i <= 4)
  {
    printf("请输入俩个操作数：");
    scanf("%d%d", &a, &b);
    ret = p[i](a, b);
    printf("%d\n", ret);
  }
  else if (i == 0)
  {
    printf("计算结束！\n");
  }
  else
  {
    printf("输入错误！\n");
  }
  } while (i);
  return 0;
}

输出结果：

使用函数指针数组后，代码变得更加简洁。