[数据结构与算法]【指针套娃】指针进阶详解

前言

首先我们再来回顾一下指针的概念

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的+（-）整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。

一、字符指针

字符指针一般有两种：

int main()
{
    //第一种，指向单个字符
    char ch='w';
    char* p=&ch;
    
    //第二种，指向一个常量字符串
    char* ptr="hello world!";//但是ptr存放的是整个字符串吗？
    return 0；
}

特别容易以为是把常量字符串 hello world! 放到字符指针 ptr 里了，但是本质是把字符串 首字符的地址放到了ptr中，也就是说ptr指向的是’h’的地址，但是字符串在内存中是连续存储，且串末尾系统自动加上’\0’结尾，所有当用%s输出字符串时，它会从第一个元素持续输出到’\0’结束。

那就有这样的面试题：

#include <stdio.h>
int main()
{
  char str1[] = "hello world!";
  char str2[] = "hello world!";
  char *str3 = "hello world!";
  char *str4 = "hello world!";
  if(str1 ==str2)
	printf("str1 and str2 are same\n");
  else
	printf("str1 and str2 are not same\n");

  if(str3 ==str4)
	printf("str3 and str4 are same\n");
  else
	printf("str3 and str4 are not same\n");
  return 0;
}

请在心中默念出你的答案。

从上面知道，字符指针，数组指针存放的都是元素的首地址，所以比较的就是首地址。

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

二、指针数组

前面我们也学习了指针数组

这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; //整形指针的数组(存放整形指针)
char *arr2[4]; //一级字符指针的数组(存放字符指针)
char **arr3[5];//二级字符指针的数组(存放二级字符指针)

如何判断数组存放的类型呢？

很简单，直接去掉” 数组名[] “剩下的就是数组存放的类型。

三、数组指针

数组指针的定义

数组指针是指针？还是数组？
答案是：指针。

我们可以根据以往的学习来推导，字符指针char* p，整型指针int* p。
所以数组指针应该是：能够指向数组的指针。
那如何来表示呢
首先它是一个指针，那定义时就需要在变量前加*，其次它指向的类型又是一个数组，所以有以下定义

int arr[10]={0};
//定义一个数组指针parr指向arr
int (*parr)[10]=&arr;
//*parr必须用括号括起来，因为[]的优先级高于*

也可以是从表达式来解释
parr先和*结合，说明parr是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

int main()
{
	int a = 10;
	int* pi = &a;//整型的地址存放在整型指针中
	char ch = 'w';
	char* pc = &ch;//字符的地址存放在字符指针中

	int arr[10] = {0};
	int* p = arr;// -是数组首元素的地址

	//int* parr[10]; //这样写是数组
	int (*parr)[10] = &arr;//取出的是数组的地址, 应该存放到数组指针中

	return 0;
}

&数组名VS数组名

对于下面的数组：

int arr[10];

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：

#include <stdio.h>
int main()
{
  int arr[10] = {0};
  printf("%p\n",&arr[0]);
  printf("%p\n", arr);
  printf("%p\n", &arr);
  return 0;
}

他们的值是一样的
所以我们可以得出结论，此时的&arr和arr都是指向数组首元素，是首元素的地址，要注意的一点是他们的类型不同，分别是int ()[10]和int*。

但任何时候arr都是指向数组首元素吗？

给出结论：arr在不同的地方有不同的含义。
当数组名（arr）除以下两种情况外都是首元素地址

1. sizeof(数组名)， 这里的数组名是表示整个数组的，sizeof(数组名)计算的是整个数组的大小，单位是字节
2. &数组名， 这里的数组名不是首元素的地址，数组名表示整个数组，所以取出的是整个数组的地址

代码如下：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };

	//计算整个数组大小
	printf("%d\n", sizeof(arr));
	
	//取出来的地址是整个数组的地址
	int(*parr)[10] = &arr;
	return 0;
}

我们来看一下区别

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//arr是首元素地址
	//&arr[0]是首元素地址
	//&arr取出数组的地址

	printf("%p\n",arr );
	printf("%p\n",&arr[0] );
	printf("%p\n", &arr);

	printf("%p\n", arr+1);
	printf("%p\n", &arr[0]+1);
	printf("%p\n", &arr+1);

	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(&arr));


	int(*parr)[10] = &arr;
	return 0;
}

总结：

• arr（不属于两个例外）和&arr[0]都是首元素地址
• &arr是数组的地址，而不是数组首元素的地址，所以 &arr+1是跳过整个数组（40个字节）
• 首元素地址+1是第二个元素的地址
• sizeof(arr)是求得整个数组大小
• 是地址大小都为4/8

数组指针的使用

那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：

#include <stdio.h>
int main()
{
  int arr[10] = {1,2,3,4,5,6,7,8,9,0};
  int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
  //但是我们一般很少这样写代码
  return 0;
}

四、函数指针

也就是指向函数的指针，存放函数的地址。
来看一段代码

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

两个的值都是函数的地址。那怎么保存函数的地址呢？

需要定义一个函数指针来接收函数的地址。
首先函数指针是一个指针，需要先与 * 结合，然后在与 () 结合，表明指向一个函数，()里面放函数的形参类型。还有函数的返回值。

void test()
{
	printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

void (*pfun1)();//先和*结合，是一个指针，()表示指向一个函数，void表示函数的返回值。
void *pfun2();//先和()结合，是函数的声明，返回值是void*。

int Add(int x,int y)
{
	return x + y;
}

//定义函数指针
int (*p)(int, int)=Add;
//也可
int (*p)(int, int)=&Add;

//使用指针调用函数
int ret = p(3, 4);
int ret = (*p)(3, 4);

两段有趣的代码

//代码1
(*(void (*)())0)();
//  void (*)() 是一个函数指针类型，函数无返回值，无参
//首先将整数0的类型强制转换为一个函数指针，此时0就是一个函数指针，存放函数的地址，然后对0解引用，再()调用函数，被调用的函数，无参
//所以这个代码是一次函数调用

//代码2
void (*signal(int , void(*)(int)))(int);
//首先signal先和()结合，是一个函数，函数的参数有两个，一个类型是int，一个类型是 void(*)(int) 函数指针类型，既然是函数就应该有返回类型
//把signal(int , void(*)(int)),去掉后就是函数的返回类型 void(*)(int) ，是一个函数指针，该函数返回类型为空，参数为空。
//所以语句本质是一个函数声明
//函数名是signal

函数指针类型看着很复杂，也不方便使用，我们可以使用 typedef 定义一个别名

//我们知道
typedef int DataType;
//类似定义
typedef void(* pfun )(int);
//pfun就是类型别名
//我们可以直接使用，来定义函数指针变量
pfun pAdd = &Add;

//同样也可以把上述void (*signal(int , void(*)(int)))(int);简化
pfun signal(int, pfun);

五、函数指针数组

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

首先，是一个数组，那就要先和下标运算符[]结合，其次才是函数指针类型

int (* arr[10])(int, int);
//数组有十个元素，每个元素类型是int (*)(int, int) 函数指针，该函数返回类型是int，有两个参数，都是int类型。

函数指针数组的应用——转移表

转移表
也就是将返回类型，参数个数和类型相同的函数放在一个数组里面，然后应对不同的情况使用数组来调用每个函数。
例如，定义加、减、乘、除四个函数，他们的返回类型，参数个数和类型相同，将他们放在一个数组里面。

int (* arr[4])(int, int)={add, sub, mul, div };
//调用
int ret = (*p[input])(x, y);

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

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

定义
首先它是一个指针，先与 * 结合-(*parr)，然后再和 [] 结合，表明指向一个数组- (*parr)[4]，然后是数组的元素类型-函数指针 int (*) (int, int)

int (*(*parr)[4])(int, int) = &arr;

七、回调函数

定义

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

#include<stdio.h>

int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}
void test(int (*pfun)(int, int))
{
	int ret = pfun(3, 4);//通过函数指针去调用其他函数
	printf("%d\n", ret);
}
int main()
{
	test(Add);//将函数的地址作为参数
	test(Sub);
	return 0;
}

总结

希望能对你理解深入的指针有所帮助！