?其中*(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字，又破記錄了，以后還想寫一個指針的面試題的總結，加深一下這一塊內容的理解，學習指針調試的方面也很重要但這里沒多贅述，最后祝大家學業有成吧（比心）。