其中*(p+i)与arr[i]是等价的。

3.指针数组

指针数组，顾名思义就是存放指针的数组，我们可以类比：

int arr[10];//整型数组，存放整型的数组char ch[5];//字符数组，存放字符的数组int* parr[10];//指针数组，存放指针的数组

即数组中存放的全都是指针。举个例子：

int a=10;int b=90;int c=40;int* parr[3]={&a,&b,&c};

将a,b,c的地址存放在了指针数组中。

再来看一段代码：

#includeint main(){	int arr1[] = { 1,2,3,4,5 };	int arr2[] = { 2,3,4,5,6 };	int arr3[] = { 3,4,5,6,7 };	int* arr4[] = {arr1,arr2,arr3};	int i,j;	for (i = 0; i < 3; i++)	{		for (j = 0; j < 5; j++)		{			printf("%d ", arr4[i][j]);		}		printf("/n");	}	return 0;}

 我们可以看到这段代码的运行结果。注意printf后面的部分用法，arr4[i][j]并不是二维数组，假设我们要得到arr1中1这个元素，首先通过arr4[0]找到arr1的首地址，然后加0得到1的地址，再对其解引用，这一过程可以写成*(arr4[0]+0)，类比一维数组中*(arr+i)与arr[i]等价，则*(arr4[0]+0)与arr4[0][0]等价。所以才有了arr[i][j]这一用法。

4.数组指针

（1）数组指针与指针数组的区别

数组指针与指针数组不同，前者强调的是指针，后者强调的是数组。

首先我们还是先进行一下类比:

int* p;//整型指针，即指向整型的指针char* pc;//字符指针，即指向字符的指针int(*p)[10];//数组指针，指向数组的指针

注意数组指针与指针数组的区分

int* p[10]表示的是p[10]是一个存放指针的指针数组，其中p是数组名。

int(*p)[10]表示的是p是一个指向有十个元素的数组的指针，且这十个元素都是整型。

在这里数组指针的类型是int(*)[10]。

（2）数组指针的使用

1.一维数组传参

来看这样一段代码

#includevoid print1(int* p, int sz){	int i;	for (i = 0; i < 10; i++)	{		printf("%d ", *(p + i));	}}void print2(int(*p)[10], int sz){	int i;	for (i = 0; i < 10; i++)	{		printf("%d ", *(*p + i));	}}int main(){	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };	int sz = sizeof(arr) / sizeof(arr[0]);	print1(arr, sz);	printf("/n");	print2(&arr, sz);	return 0;}

 这段代码用两种不同的传参方式，打印出来相同的结果。

向print1向传的参数是数组首元素的地址。

向print2这个函数传的参数是整个数组的地址，因为&数组名表示的是真个数组的地址。

print1接收的是首元素地址，只需要一个整型指针就可以接收。

print2接收的是整个数组的地址，所以需要用指针数组来接收。

重点讲一下print2函数是如何将数组的所有元素成功打印的：

 重点在于这个部分，首先我们知道p是一个指向整个数组的指针。

规定：对指向整个数组的指针进行解引用的结果是整个数组的首元素的地址。

则*p是数组arr的首元素的地址，结合之前讲的用指针操作数组，可以知道*(*p+i)表示的是数组中的元素，其中*p可以改写成*(p+0)，所以p[0]表示的也是数组首元素的地址，整个表达式可以改写成这样：p[0][i]，这与上面的表达式是等价的。

对于一位数组，其实并不建议这么传参，原因是比较绕，容易混淆。

 2.二维数组传参

来看这样一段代码

#includevoid print1(int arr[3][5], int r, int c){	int i, j;	for (i = 0; i < r; i++)	{		for (j = 0; j < c; j++)		{			printf("%d ", arr[i][j]);		}		printf("/n");	}}void print2(int(*p)[5], int r, int c){	int i, j;	for (i = 0; i < r; i++)	{		for (j = 0; j < c; j++)		{			printf("%d ", *(*(p + 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 };	print1(arr, 3, 5);	printf("/n/n");	print2(arr, 3, 5);	return 0;}

 我们可以看到，接收参数的方式不同，打印的结果是相同的，其中print1是常规操作，我们重点说一下print2这个函数。

 首先我们要知道：二维数组的数组名表示的是第一行的地址。

这也是我们可以用数组指针来接收二维数组数组名的原因。

整个问题的关键所在还是在这段代码上。

我们已经明确p表示的是第一行的地址，那么根据指针运算的部分我们可以知道(p+i)表示的是第i行的地址，对(p+i)解引用，找到的是第i行第一个元素的地址，对这个地址+j表示的是这一行第j个元素的地址，再解引用，表示的就是第i行第j列的元素内容。 

 由于*(p+i)等价于p[i]所以整个表达式等价于p[i][j]。打印的结果是一样的。

5.总结

1.区分概念

int arr[5];//一个整型数组int *parr[10];//一个指针数组，数组的每个元素都是指针int(*parr2)[10];//一个数组指针，这是一个指向含有十个整型元素的数组的指针int (*parr3[10])[5];//parr3是一个指针数组，数组中存放的是指针                    //parr3中每一个元素指向含有5个整型元素的数组

2.一维数组传参

int arr[10]={0};test(arr);

现在定义一个数组，以数组名为参数，形参的几种形式

void test(int arr[]);void test(int arr[10]);void test(int *arr);//数组名是首元素地址可以用指针接收

若定义的值一个指针数组：

int *arr[10]={0};test(arr);

形参的形式可以是：

void test(int *arr[10]);void test(int **arr);//由于数组名时首元素地址，首元素是一个指针，能够接收指针地址的是二级指针

3.二级指针传参

int arr[3][5]={0};test(arr);

形参的形式可以是：

void test(int arr[3][5]);void test(int arr[][5]);//注意列不可以省void test(int (*p)[5]);//二维数组数组名表示的是第一行的地址

六.二级指针

我们知道指针存放的是某一个元素的地址，但是指针依然是一个变量，指针也有它自己的地址。

int a=10;int*p=&a;printf("%d",*p);//10int**pp=&p;//定义二级指针pp，并使pp指向p的地址printf("%d",**p);//相当于两次解引用，结果依然是10

那你可能会问了二级指针的地址是不是用int***类型的变量存储呢，答案是肯定的，理论上来说是可以无限套娃的，但是用多了之后你会发现代码会变得冗余可读性变差，所以不建议无限套娃。

七.字符指针

1.第一种形式

char ch="w";char*p =&ch;

这种形式和整型指针一样，指针指向一个字符的地址。

2.第二种形式

char*pc="hello world";//hello world是一个常量字符串，存放在内存的常量区，不允许改printf("%c",*p);//打印出来的是第一个字符hprintf("%s",p);//打印出来的是整个字符串hello world

当指针指向字符串时，对它解引用得到的是字符串的第一个字符，当打印整个字符串时，将%c改成%s，不需要再解引用，这是由printf这个函数本身性质所决定的。

根据这一特征我们可以通过指针数组打印多组字符串。

int i;char* arr[3]={"abcd","efgh","ijkl"};for(i=0;i<3;i++){printf("%s",arr[i]);};

值得注意的是，此时的hello world是一个常量字符串，是无法通过*p修改的，如果加上*p="w"的话，编译器会报错。

八.函数指针

所谓函数指针，就是可以指向函数的指针，函数和各类型变量一样，也有自己的地址。

1.函数的地址

#includeint add(int a, int b);int add(int a, int b){	return a + b;}int main(){	printf("%p/n", add);	printf("%p", &add);}

这段代码打印的结果是

我们可以看到，无论是否在函数add前加上&，打印出来的结果是一样的，这说明add和&add都代表着函数的地址。

2.函数指针

既然函数有地址，那么一定有相应类型的指针变量去接收它的地址。并有相应的解引用操作。我们用函数操作和函数指针操作进行一下对比。

#includeint add(int a, int b);int add(int a, int b){	return a + b;}int main(){	int (*p)(int, int) = add;	int ret = add(2, 3);	printf("%d/n", ret);	ret = (*p)(2, 3);	printf("%d", ret);	return 0;}

 1.函数指针的定义

这一部分为函数指针的定义部分，前面讲过，add可以表示函数的地址。这里的函数指针名为p，p前面的*代表它是一个指针，后面的（int,int）表示这个指针所指向函数的参数为两个int型的参数，最前面的int表示的是这个指针所指函数的返回值是int型。该函数指针的类型为int(*)(int,int)。

 2.函数指针的解引用

 我们可以看到，这段代码打印的结果依然是5，这里的p是一个指向函数add的指针，*对p解引用得到函数add，再向add传参2和3，从而得到add的返回值5。

规定：在解引用函数指针时，*可以填多个，也可以不填。也就是说ret=(*p)(2,3)可以改写成p(2,3),也可以改写成(**p)(2,3)。

3.函数指针的两个复杂的例子

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

我们来分析一下这段代码，分析这种复杂的代码时一定要先找到每个括号的位置。

我们将它一层一层展开，首先是这一部分(void(*)())0，前面括号里面的void(*)()是一个没有返回值，没有参数的函数指针类型，后面的0是一个整型，在函数指针类型上加括号表示的是，将0这个整型强行转换成函数指针类型。即0变成了一个函数指针。

现在的代码被简化成了(*0)()，其中0是函数指针类型，对其解引用找到了这个函数，由于0这个函数指针的类型是void(*)()，所以对0这个函数指针解引用时要传递的类型就是()，即原式是对0这个指针变量解引用的结果。

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

再来看这样一段代码，signal(int,void(*)(int))这一段先不看先用a来代替，剩余的就是void(*a)(int)这样一段内容，很明显这是一个函数指针的定义，即a就是一个函数指针，即signal(int,void(*)(int))是一个函数指针，即signal是一个函数，它的返回值是一个函数指针，它的参数类型是整型int和函数指针类型void(*)(int)。

这样一段代码看起来很复杂，可以用typedef来简化一下，我们可以先这样定义：

typedef void(*p)(int) ，注意这不是定义了一个函数指针，而是将函数指针类型定义成了p,即p代表void(*p)(int)这一类型，这样的话原代码就可以改写成p signal(int,p),比原来看起来会简便多了。

3.函数指针的应用

函数指针可以简化很多操作，尤其是对那种需要调用多个相似函数的程序有奇效。原理就是可以将每一个相同类型的函数放在函数指针数组中。

我们拿实现计算器作一个对比

首先是没用到函数指针的计算器：

#includeint 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;}void menu(){	printf("**1.add***/n");	printf("**2.sub***/n");	printf("**3.mul***/n");	printf("**4.piv***/n");	printf("**0.exit**/n");}int main(){	int input=0;	menu();	do {		printf("please input your choice!/n");		scanf("%d", &input);		int a, b,ret;		switch (input)		{		case 1:scanf("%d %d", &a, &b);			ret=add(a, b);			printf("%d/n", ret);			break;		case 2:scanf("%d %d", &a, &b);			ret=sub(a, b);			printf("%d/n", ret);			break;		case 3:scanf("%d %d", &a, &b);			ret = mul(a, b);			printf("%d/n", ret);			break;		case 4:scanf("%d %d", &a, &b);			ret = div(a, b);			printf("%d/n", ret);			break;		case 0:printf("exit!");			break;		default:printf("error!/n");			break;		}	} while (input);	return 0;}

这个程序很容易理解，用switch语句选择不同的计算操作就能实现计算功能。然而这段代码还是国语冗余，我们可以思考一下函数指针的方法。

#define _CRT_SECURE_NO_WARNINGS#includeint 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;}void menu(){	printf("**1.add***/n");	printf("**2.sub***/n");	printf("**3.mul***/n");	printf("**4.piv***/n");	printf("**0.exit**/n");}int main(){	int input = 0;	menu();	int (*p[5])(int, int) = { 0,add,sub,mul,div };//定义一个函数指针数组用来存储四个函数的地址，0起到补位作用。	do {		scanf("%d", &input);		if (input == 0)		{			printf("exit/n");			break;		}		else if (input >= 1 && input <= 4)		{			int a, b, ret;			scanf("%d %d", &a, &b);			ret = (*p[input])(a, b);//对函数指针进行解引用找到对应的函数。			printf("%d/n", ret);		}		else		{			printf("error!/n");		}	} while (input);	return 0;}

 这样一来的话判断语句更简便了，所需要的代码量也变少了。得到的结果是相同的。

3.回调函数

1.定义

定义：回调函数就是一个通过函数指针调用的函数，如果你把函数的地址作为参数传给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

 仍然拿计算器这个程序举例：

#includeint 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;}void calc(int (*p)(int, int))//定义一个函数接收各函数地址{	int a, b, ret;	scanf("%d %d", &a, &b);	ret = (*p)(a, b);	printf("%d/n", ret);}void menu(){	printf("**1.add***/n");	printf("**2.sub***/n");	printf("**3.mul***/n");	printf("**4.piv***/n");	printf("**0.exit**/n");}int main(){	int input = 0;	menu();	do {		printf("please input your choice!/n");		scanf("%d", &input);		int a, b, ret;		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("exit!");			break;		default:printf("error!/n");			break;		}	} while (input);	return 0;}

这个方式也比第一种方式简单的多，新定义了一个函数接收各个函数的地址，在每个case中只需要引用一个calc函数就可以了,这种方式利用函数指针解决了每个case中相同代码较多的问题。

回调函数还是很重要的，刚刚看了几个指针的面试题，都有涉及到回调函数，所以再给大家举一个例子。

2.qsort函数(void*)

我们知道c语言中有许多我们还很少用到的库函数，比如qsort函数，这是一个快速排序函数，和回调函数就有很大的联系。这个函数的功能很强大，不仅能排序整数，甚至结构体便量也可以排序。这里只排整型变量，对排结构体感兴趣的小伙伴可以研究一下呀。

首先我们先看一下这个函数的参数：

 这是msdn中给到的函数定义，我们逐个来介绍

1.void*base：定义了一个空类型的指针，空类型的指针可以指向所有类型的地址，但是不能解引用和进行指针加减运算。这里的base表示的是指向首元素的指针。

2.size_t num和size_t width：前者代表的是元素的个数，后者代表每个元素所占字节数。

3.int (__cdecl*compare)(const void*elem1,const void*elem2)：这里定义了一个函数指针，所指向的是判断相邻两个数据的大小的一个函数即传了一个函数名，也是函数的地址。对这个函数也有一定的要求。这里的两个数据也是先用的void*来接收的地址。

下面用一段代码来展示一下这个函数怎么用：

#include#includeint compare(const void* e1, const void* e2){	return *(int*)e1 - *(int*)e2;}int main(){	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };	int sz = sizeof(arr) / sizeof(arr[0]);	qsort(arr, sz, sizeof(arr[0]), compare);	int i = 0;	for (i = 0; i < 10; i++)	{		printf("%d ", arr[i]);	}	return 0;}

 注意我们向qsort函数传的参数

 compare函数的参数是两个空类型的指针，传入的是arr数组两个相邻数的地址，前面讲过，void*类型是不能解引用的，所以我们要先将其强制转换成int*类型，然后再解引用。

 英语差的我还特意百度了一下这段话的意思，就是说当e1>e2时，如果我定义的函数返回值大于0的话，那么e1就会排在e2的后面，反过来如果我定义的函数返回值小于0，那么e1就会排在e2的前面。

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

我们还是逐层取理解

int (*p)(int ,int)=add;//p是一个函数指针int (*p[4])(int,int)={add,sub,mul,div};//p是一个函数指针数组，每个元素存放一个函数地址int (*(*p)[4])(int, int);//p是一个指向函数指针数组的指针

这段代码如何理解呢？首先看(*p)[4]这一部分，*与p结合表示p是一个指针，再与[10]结合，表示这个指针指向的是一个数组，该数组里有4个元素，在将(*p)[4]排除，剩余部分为int (*)(int,int)，这一部分代表数组中每一个元素的类型，类型是函数指针类型，所以p是一个指向函数指针数组的指针。

九.总结

感谢大家可以看到这里，呕心沥血了接近5天，总算是呕完了，喜欢的别忘收藏一下，关注一下我啥的，不知道小伙伴们站起来了吗，全文12000字，又破记录了，以后还想写一个指针的面试题的总结，加深一下这一块内容的理解，学习指针调试的方面也很重要但这里没多赘述，最后祝大家学业有成吧（比心）。